1 //===--- ASTReader.cpp - AST File Reader ----------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file defines the ASTReader class, which reads AST files.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Serialization/ASTReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/NestedNameSpecifier.h"
23 #include "clang/AST/Type.h"
24 #include "clang/AST/TypeLocVisitor.h"
25 #include "clang/Basic/DiagnosticOptions.h"
26 #include "clang/Basic/FileManager.h"
27 #include "clang/Basic/SourceManager.h"
28 #include "clang/Basic/SourceManagerInternals.h"
29 #include "clang/Basic/TargetInfo.h"
30 #include "clang/Basic/TargetOptions.h"
31 #include "clang/Basic/Version.h"
32 #include "clang/Basic/VersionTuple.h"
33 #include "clang/Frontend/Utils.h"
34 #include "clang/Lex/HeaderSearch.h"
35 #include "clang/Lex/HeaderSearchOptions.h"
36 #include "clang/Lex/MacroInfo.h"
37 #include "clang/Lex/PreprocessingRecord.h"
38 #include "clang/Lex/Preprocessor.h"
39 #include "clang/Lex/PreprocessorOptions.h"
40 #include "clang/Sema/Scope.h"
41 #include "clang/Sema/Sema.h"
42 #include "clang/Serialization/ASTDeserializationListener.h"
43 #include "clang/Serialization/GlobalModuleIndex.h"
44 #include "clang/Serialization/ModuleManager.h"
45 #include "clang/Serialization/SerializationDiagnostic.h"
46 #include "llvm/ADT/Hashing.h"
47 #include "llvm/ADT/StringExtras.h"
48 #include "llvm/Bitcode/BitstreamReader.h"
49 #include "llvm/Support/ErrorHandling.h"
50 #include "llvm/Support/FileSystem.h"
51 #include "llvm/Support/MemoryBuffer.h"
52 #include "llvm/Support/Path.h"
53 #include "llvm/Support/SaveAndRestore.h"
54 #include "llvm/Support/raw_ostream.h"
55 #include <algorithm>
56 #include <cstdio>
57 #include <iterator>
58 #include <system_error>
59 
60 using namespace clang;
61 using namespace clang::serialization;
62 using namespace clang::serialization::reader;
63 using llvm::BitstreamCursor;
64 
65 
66 //===----------------------------------------------------------------------===//
67 // ChainedASTReaderListener implementation
68 //===----------------------------------------------------------------------===//
69 
70 bool
71 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
72   return First->ReadFullVersionInformation(FullVersion) ||
73          Second->ReadFullVersionInformation(FullVersion);
74 }
75 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
76   First->ReadModuleName(ModuleName);
77   Second->ReadModuleName(ModuleName);
78 }
79 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
80   First->ReadModuleMapFile(ModuleMapPath);
81   Second->ReadModuleMapFile(ModuleMapPath);
82 }
83 bool
84 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
85                                               bool Complain,
86                                               bool AllowCompatibleDifferences) {
87   return First->ReadLanguageOptions(LangOpts, Complain,
88                                     AllowCompatibleDifferences) ||
89          Second->ReadLanguageOptions(LangOpts, Complain,
90                                      AllowCompatibleDifferences);
91 }
92 bool
93 ChainedASTReaderListener::ReadTargetOptions(const TargetOptions &TargetOpts,
94                                             bool Complain) {
95   return First->ReadTargetOptions(TargetOpts, Complain) ||
96          Second->ReadTargetOptions(TargetOpts, Complain);
97 }
98 bool ChainedASTReaderListener::ReadDiagnosticOptions(
99     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
100   return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
101          Second->ReadDiagnosticOptions(DiagOpts, Complain);
102 }
103 bool
104 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
105                                                 bool Complain) {
106   return First->ReadFileSystemOptions(FSOpts, Complain) ||
107          Second->ReadFileSystemOptions(FSOpts, Complain);
108 }
109 
110 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
111     const HeaderSearchOptions &HSOpts, bool Complain) {
112   return First->ReadHeaderSearchOptions(HSOpts, Complain) ||
113          Second->ReadHeaderSearchOptions(HSOpts, Complain);
114 }
115 bool ChainedASTReaderListener::ReadPreprocessorOptions(
116     const PreprocessorOptions &PPOpts, bool Complain,
117     std::string &SuggestedPredefines) {
118   return First->ReadPreprocessorOptions(PPOpts, Complain,
119                                         SuggestedPredefines) ||
120          Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
121 }
122 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
123                                            unsigned Value) {
124   First->ReadCounter(M, Value);
125   Second->ReadCounter(M, Value);
126 }
127 bool ChainedASTReaderListener::needsInputFileVisitation() {
128   return First->needsInputFileVisitation() ||
129          Second->needsInputFileVisitation();
130 }
131 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
132   return First->needsSystemInputFileVisitation() ||
133   Second->needsSystemInputFileVisitation();
134 }
135 void ChainedASTReaderListener::visitModuleFile(StringRef Filename) {
136   First->visitModuleFile(Filename);
137   Second->visitModuleFile(Filename);
138 }
139 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
140                                               bool isSystem,
141                                               bool isOverridden) {
142   bool Continue = false;
143   if (First->needsInputFileVisitation() &&
144       (!isSystem || First->needsSystemInputFileVisitation()))
145     Continue |= First->visitInputFile(Filename, isSystem, isOverridden);
146   if (Second->needsInputFileVisitation() &&
147       (!isSystem || Second->needsSystemInputFileVisitation()))
148     Continue |= Second->visitInputFile(Filename, isSystem, isOverridden);
149   return Continue;
150 }
151 
152 //===----------------------------------------------------------------------===//
153 // PCH validator implementation
154 //===----------------------------------------------------------------------===//
155 
156 ASTReaderListener::~ASTReaderListener() {}
157 
158 /// \brief Compare the given set of language options against an existing set of
159 /// language options.
160 ///
161 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
162 /// \param AllowCompatibleDifferences If true, differences between compatible
163 ///        language options will be permitted.
164 ///
165 /// \returns true if the languagae options mis-match, false otherwise.
166 static bool checkLanguageOptions(const LangOptions &LangOpts,
167                                  const LangOptions &ExistingLangOpts,
168                                  DiagnosticsEngine *Diags,
169                                  bool AllowCompatibleDifferences = true) {
170 #define LANGOPT(Name, Bits, Default, Description)                 \
171   if (ExistingLangOpts.Name != LangOpts.Name) {                   \
172     if (Diags)                                                    \
173       Diags->Report(diag::err_pch_langopt_mismatch)               \
174         << Description << LangOpts.Name << ExistingLangOpts.Name; \
175     return true;                                                  \
176   }
177 
178 #define VALUE_LANGOPT(Name, Bits, Default, Description)   \
179   if (ExistingLangOpts.Name != LangOpts.Name) {           \
180     if (Diags)                                            \
181       Diags->Report(diag::err_pch_langopt_value_mismatch) \
182         << Description;                                   \
183     return true;                                          \
184   }
185 
186 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)   \
187   if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) {  \
188     if (Diags)                                                 \
189       Diags->Report(diag::err_pch_langopt_value_mismatch)      \
190         << Description;                                        \
191     return true;                                               \
192   }
193 
194 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description)  \
195   if (!AllowCompatibleDifferences)                            \
196     LANGOPT(Name, Bits, Default, Description)
197 
198 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description)  \
199   if (!AllowCompatibleDifferences)                                 \
200     ENUM_LANGOPT(Name, Bits, Default, Description)
201 
202 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
203 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
204 #include "clang/Basic/LangOptions.def"
205 
206   if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
207     if (Diags)
208       Diags->Report(diag::err_pch_langopt_value_mismatch)
209       << "target Objective-C runtime";
210     return true;
211   }
212 
213   if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
214       LangOpts.CommentOpts.BlockCommandNames) {
215     if (Diags)
216       Diags->Report(diag::err_pch_langopt_value_mismatch)
217         << "block command names";
218     return true;
219   }
220 
221   return false;
222 }
223 
224 /// \brief Compare the given set of target options against an existing set of
225 /// target options.
226 ///
227 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
228 ///
229 /// \returns true if the target options mis-match, false otherwise.
230 static bool checkTargetOptions(const TargetOptions &TargetOpts,
231                                const TargetOptions &ExistingTargetOpts,
232                                DiagnosticsEngine *Diags) {
233 #define CHECK_TARGET_OPT(Field, Name)                             \
234   if (TargetOpts.Field != ExistingTargetOpts.Field) {             \
235     if (Diags)                                                    \
236       Diags->Report(diag::err_pch_targetopt_mismatch)             \
237         << Name << TargetOpts.Field << ExistingTargetOpts.Field;  \
238     return true;                                                  \
239   }
240 
241   CHECK_TARGET_OPT(Triple, "target");
242   CHECK_TARGET_OPT(CPU, "target CPU");
243   CHECK_TARGET_OPT(ABI, "target ABI");
244 #undef CHECK_TARGET_OPT
245 
246   // Compare feature sets.
247   SmallVector<StringRef, 4> ExistingFeatures(
248                                              ExistingTargetOpts.FeaturesAsWritten.begin(),
249                                              ExistingTargetOpts.FeaturesAsWritten.end());
250   SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
251                                          TargetOpts.FeaturesAsWritten.end());
252   std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
253   std::sort(ReadFeatures.begin(), ReadFeatures.end());
254 
255   unsigned ExistingIdx = 0, ExistingN = ExistingFeatures.size();
256   unsigned ReadIdx = 0, ReadN = ReadFeatures.size();
257   while (ExistingIdx < ExistingN && ReadIdx < ReadN) {
258     if (ExistingFeatures[ExistingIdx] == ReadFeatures[ReadIdx]) {
259       ++ExistingIdx;
260       ++ReadIdx;
261       continue;
262     }
263 
264     if (ReadFeatures[ReadIdx] < ExistingFeatures[ExistingIdx]) {
265       if (Diags)
266         Diags->Report(diag::err_pch_targetopt_feature_mismatch)
267           << false << ReadFeatures[ReadIdx];
268       return true;
269     }
270 
271     if (Diags)
272       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
273         << true << ExistingFeatures[ExistingIdx];
274     return true;
275   }
276 
277   if (ExistingIdx < ExistingN) {
278     if (Diags)
279       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
280         << true << ExistingFeatures[ExistingIdx];
281     return true;
282   }
283 
284   if (ReadIdx < ReadN) {
285     if (Diags)
286       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
287         << false << ReadFeatures[ReadIdx];
288     return true;
289   }
290 
291   return false;
292 }
293 
294 bool
295 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
296                                   bool Complain,
297                                   bool AllowCompatibleDifferences) {
298   const LangOptions &ExistingLangOpts = PP.getLangOpts();
299   return checkLanguageOptions(LangOpts, ExistingLangOpts,
300                               Complain ? &Reader.Diags : nullptr,
301                               AllowCompatibleDifferences);
302 }
303 
304 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
305                                      bool Complain) {
306   const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
307   return checkTargetOptions(TargetOpts, ExistingTargetOpts,
308                             Complain? &Reader.Diags : nullptr);
309 }
310 
311 namespace {
312   typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
313     MacroDefinitionsMap;
314   typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
315     DeclsMap;
316 }
317 
318 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
319                                          DiagnosticsEngine &Diags,
320                                          bool Complain) {
321   typedef DiagnosticsEngine::Level Level;
322 
323   // Check current mappings for new -Werror mappings, and the stored mappings
324   // for cases that were explicitly mapped to *not* be errors that are now
325   // errors because of options like -Werror.
326   DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
327 
328   for (DiagnosticsEngine *MappingSource : MappingSources) {
329     for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
330       diag::kind DiagID = DiagIDMappingPair.first;
331       Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
332       if (CurLevel < DiagnosticsEngine::Error)
333         continue; // not significant
334       Level StoredLevel =
335           StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
336       if (StoredLevel < DiagnosticsEngine::Error) {
337         if (Complain)
338           Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
339               Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
340         return true;
341       }
342     }
343   }
344 
345   return false;
346 }
347 
348 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
349   diag::Severity Ext = Diags.getExtensionHandlingBehavior();
350   if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
351     return true;
352   return Ext >= diag::Severity::Error;
353 }
354 
355 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
356                                     DiagnosticsEngine &Diags,
357                                     bool IsSystem, bool Complain) {
358   // Top-level options
359   if (IsSystem) {
360     if (Diags.getSuppressSystemWarnings())
361       return false;
362     // If -Wsystem-headers was not enabled before, be conservative
363     if (StoredDiags.getSuppressSystemWarnings()) {
364       if (Complain)
365         Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
366       return true;
367     }
368   }
369 
370   if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
371     if (Complain)
372       Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
373     return true;
374   }
375 
376   if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
377       !StoredDiags.getEnableAllWarnings()) {
378     if (Complain)
379       Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
380     return true;
381   }
382 
383   if (isExtHandlingFromDiagsError(Diags) &&
384       !isExtHandlingFromDiagsError(StoredDiags)) {
385     if (Complain)
386       Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
387     return true;
388   }
389 
390   return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
391 }
392 
393 bool PCHValidator::ReadDiagnosticOptions(
394     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
395   DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
396   IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
397   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
398       new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
399   // This should never fail, because we would have processed these options
400   // before writing them to an ASTFile.
401   ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
402 
403   ModuleManager &ModuleMgr = Reader.getModuleManager();
404   assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
405 
406   // If the original import came from a file explicitly generated by the user,
407   // don't check the diagnostic mappings.
408   // FIXME: currently this is approximated by checking whether this is not a
409   // module import of an implicitly-loaded module file.
410   // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
411   // the transitive closure of its imports, since unrelated modules cannot be
412   // imported until after this module finishes validation.
413   ModuleFile *TopImport = *ModuleMgr.rbegin();
414   while (!TopImport->ImportedBy.empty())
415     TopImport = TopImport->ImportedBy[0];
416   if (TopImport->Kind != MK_ImplicitModule)
417     return false;
418 
419   StringRef ModuleName = TopImport->ModuleName;
420   assert(!ModuleName.empty() && "diagnostic options read before module name");
421 
422   Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
423   assert(M && "missing module");
424 
425   // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
426   // contains the union of their flags.
427   return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain);
428 }
429 
430 /// \brief Collect the macro definitions provided by the given preprocessor
431 /// options.
432 static void
433 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
434                         MacroDefinitionsMap &Macros,
435                         SmallVectorImpl<StringRef> *MacroNames = nullptr) {
436   for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
437     StringRef Macro = PPOpts.Macros[I].first;
438     bool IsUndef = PPOpts.Macros[I].second;
439 
440     std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
441     StringRef MacroName = MacroPair.first;
442     StringRef MacroBody = MacroPair.second;
443 
444     // For an #undef'd macro, we only care about the name.
445     if (IsUndef) {
446       if (MacroNames && !Macros.count(MacroName))
447         MacroNames->push_back(MacroName);
448 
449       Macros[MacroName] = std::make_pair("", true);
450       continue;
451     }
452 
453     // For a #define'd macro, figure out the actual definition.
454     if (MacroName.size() == Macro.size())
455       MacroBody = "1";
456     else {
457       // Note: GCC drops anything following an end-of-line character.
458       StringRef::size_type End = MacroBody.find_first_of("\n\r");
459       MacroBody = MacroBody.substr(0, End);
460     }
461 
462     if (MacroNames && !Macros.count(MacroName))
463       MacroNames->push_back(MacroName);
464     Macros[MacroName] = std::make_pair(MacroBody, false);
465   }
466 }
467 
468 /// \brief Check the preprocessor options deserialized from the control block
469 /// against the preprocessor options in an existing preprocessor.
470 ///
471 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
472 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
473                                      const PreprocessorOptions &ExistingPPOpts,
474                                      DiagnosticsEngine *Diags,
475                                      FileManager &FileMgr,
476                                      std::string &SuggestedPredefines,
477                                      const LangOptions &LangOpts) {
478   // Check macro definitions.
479   MacroDefinitionsMap ASTFileMacros;
480   collectMacroDefinitions(PPOpts, ASTFileMacros);
481   MacroDefinitionsMap ExistingMacros;
482   SmallVector<StringRef, 4> ExistingMacroNames;
483   collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
484 
485   for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
486     // Dig out the macro definition in the existing preprocessor options.
487     StringRef MacroName = ExistingMacroNames[I];
488     std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
489 
490     // Check whether we know anything about this macro name or not.
491     llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
492       = ASTFileMacros.find(MacroName);
493     if (Known == ASTFileMacros.end()) {
494       // FIXME: Check whether this identifier was referenced anywhere in the
495       // AST file. If so, we should reject the AST file. Unfortunately, this
496       // information isn't in the control block. What shall we do about it?
497 
498       if (Existing.second) {
499         SuggestedPredefines += "#undef ";
500         SuggestedPredefines += MacroName.str();
501         SuggestedPredefines += '\n';
502       } else {
503         SuggestedPredefines += "#define ";
504         SuggestedPredefines += MacroName.str();
505         SuggestedPredefines += ' ';
506         SuggestedPredefines += Existing.first.str();
507         SuggestedPredefines += '\n';
508       }
509       continue;
510     }
511 
512     // If the macro was defined in one but undef'd in the other, we have a
513     // conflict.
514     if (Existing.second != Known->second.second) {
515       if (Diags) {
516         Diags->Report(diag::err_pch_macro_def_undef)
517           << MacroName << Known->second.second;
518       }
519       return true;
520     }
521 
522     // If the macro was #undef'd in both, or if the macro bodies are identical,
523     // it's fine.
524     if (Existing.second || Existing.first == Known->second.first)
525       continue;
526 
527     // The macro bodies differ; complain.
528     if (Diags) {
529       Diags->Report(diag::err_pch_macro_def_conflict)
530         << MacroName << Known->second.first << Existing.first;
531     }
532     return true;
533   }
534 
535   // Check whether we're using predefines.
536   if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) {
537     if (Diags) {
538       Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
539     }
540     return true;
541   }
542 
543   // Detailed record is important since it is used for the module cache hash.
544   if (LangOpts.Modules &&
545       PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) {
546     if (Diags) {
547       Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
548     }
549     return true;
550   }
551 
552   // Compute the #include and #include_macros lines we need.
553   for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
554     StringRef File = ExistingPPOpts.Includes[I];
555     if (File == ExistingPPOpts.ImplicitPCHInclude)
556       continue;
557 
558     if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
559           != PPOpts.Includes.end())
560       continue;
561 
562     SuggestedPredefines += "#include \"";
563     SuggestedPredefines += File;
564     SuggestedPredefines += "\"\n";
565   }
566 
567   for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
568     StringRef File = ExistingPPOpts.MacroIncludes[I];
569     if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
570                   File)
571         != PPOpts.MacroIncludes.end())
572       continue;
573 
574     SuggestedPredefines += "#__include_macros \"";
575     SuggestedPredefines += File;
576     SuggestedPredefines += "\"\n##\n";
577   }
578 
579   return false;
580 }
581 
582 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
583                                            bool Complain,
584                                            std::string &SuggestedPredefines) {
585   const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
586 
587   return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
588                                   Complain? &Reader.Diags : nullptr,
589                                   PP.getFileManager(),
590                                   SuggestedPredefines,
591                                   PP.getLangOpts());
592 }
593 
594 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
595   PP.setCounterValue(Value);
596 }
597 
598 //===----------------------------------------------------------------------===//
599 // AST reader implementation
600 //===----------------------------------------------------------------------===//
601 
602 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
603                                            bool TakeOwnership) {
604   DeserializationListener = Listener;
605   OwnsDeserializationListener = TakeOwnership;
606 }
607 
608 
609 
610 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
611   return serialization::ComputeHash(Sel);
612 }
613 
614 
615 std::pair<unsigned, unsigned>
616 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
617   using namespace llvm::support;
618   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
619   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
620   return std::make_pair(KeyLen, DataLen);
621 }
622 
623 ASTSelectorLookupTrait::internal_key_type
624 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
625   using namespace llvm::support;
626   SelectorTable &SelTable = Reader.getContext().Selectors;
627   unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
628   IdentifierInfo *FirstII = Reader.getLocalIdentifier(
629       F, endian::readNext<uint32_t, little, unaligned>(d));
630   if (N == 0)
631     return SelTable.getNullarySelector(FirstII);
632   else if (N == 1)
633     return SelTable.getUnarySelector(FirstII);
634 
635   SmallVector<IdentifierInfo *, 16> Args;
636   Args.push_back(FirstII);
637   for (unsigned I = 1; I != N; ++I)
638     Args.push_back(Reader.getLocalIdentifier(
639         F, endian::readNext<uint32_t, little, unaligned>(d)));
640 
641   return SelTable.getSelector(N, Args.data());
642 }
643 
644 ASTSelectorLookupTrait::data_type
645 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
646                                  unsigned DataLen) {
647   using namespace llvm::support;
648 
649   data_type Result;
650 
651   Result.ID = Reader.getGlobalSelectorID(
652       F, endian::readNext<uint32_t, little, unaligned>(d));
653   unsigned NumInstanceMethodsAndBits =
654       endian::readNext<uint16_t, little, unaligned>(d);
655   unsigned NumFactoryMethodsAndBits =
656       endian::readNext<uint16_t, little, unaligned>(d);
657   Result.InstanceBits = NumInstanceMethodsAndBits & 0x3;
658   Result.FactoryBits = NumFactoryMethodsAndBits & 0x3;
659   unsigned NumInstanceMethods = NumInstanceMethodsAndBits >> 2;
660   unsigned NumFactoryMethods = NumFactoryMethodsAndBits >> 2;
661 
662   // Load instance methods
663   for (unsigned I = 0; I != NumInstanceMethods; ++I) {
664     if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
665             F, endian::readNext<uint32_t, little, unaligned>(d)))
666       Result.Instance.push_back(Method);
667   }
668 
669   // Load factory methods
670   for (unsigned I = 0; I != NumFactoryMethods; ++I) {
671     if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
672             F, endian::readNext<uint32_t, little, unaligned>(d)))
673       Result.Factory.push_back(Method);
674   }
675 
676   return Result;
677 }
678 
679 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
680   return llvm::HashString(a);
681 }
682 
683 std::pair<unsigned, unsigned>
684 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
685   using namespace llvm::support;
686   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
687   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
688   return std::make_pair(KeyLen, DataLen);
689 }
690 
691 ASTIdentifierLookupTraitBase::internal_key_type
692 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
693   assert(n >= 2 && d[n-1] == '\0');
694   return StringRef((const char*) d, n-1);
695 }
696 
697 /// \brief Whether the given identifier is "interesting".
698 static bool isInterestingIdentifier(IdentifierInfo &II) {
699   return II.isPoisoned() ||
700          II.isExtensionToken() ||
701          II.getObjCOrBuiltinID() ||
702          II.hasRevertedTokenIDToIdentifier() ||
703          II.hadMacroDefinition() ||
704          II.getFETokenInfo<void>();
705 }
706 
707 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
708                                                    const unsigned char* d,
709                                                    unsigned DataLen) {
710   using namespace llvm::support;
711   unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
712   bool IsInteresting = RawID & 0x01;
713 
714   // Wipe out the "is interesting" bit.
715   RawID = RawID >> 1;
716 
717   IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
718   if (!IsInteresting) {
719     // For uninteresting identifiers, just build the IdentifierInfo
720     // and associate it with the persistent ID.
721     IdentifierInfo *II = KnownII;
722     if (!II) {
723       II = &Reader.getIdentifierTable().getOwn(k);
724       KnownII = II;
725     }
726     Reader.SetIdentifierInfo(ID, II);
727     if (!II->isFromAST()) {
728       bool WasInteresting = isInterestingIdentifier(*II);
729       II->setIsFromAST();
730       if (WasInteresting)
731         II->setChangedSinceDeserialization();
732     }
733     Reader.markIdentifierUpToDate(II);
734     return II;
735   }
736 
737   unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
738   unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
739   bool CPlusPlusOperatorKeyword = Bits & 0x01;
740   Bits >>= 1;
741   bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
742   Bits >>= 1;
743   bool Poisoned = Bits & 0x01;
744   Bits >>= 1;
745   bool ExtensionToken = Bits & 0x01;
746   Bits >>= 1;
747   bool hasSubmoduleMacros = Bits & 0x01;
748   Bits >>= 1;
749   bool hadMacroDefinition = Bits & 0x01;
750   Bits >>= 1;
751 
752   assert(Bits == 0 && "Extra bits in the identifier?");
753   DataLen -= 8;
754 
755   // Build the IdentifierInfo itself and link the identifier ID with
756   // the new IdentifierInfo.
757   IdentifierInfo *II = KnownII;
758   if (!II) {
759     II = &Reader.getIdentifierTable().getOwn(StringRef(k));
760     KnownII = II;
761   }
762   Reader.markIdentifierUpToDate(II);
763   if (!II->isFromAST()) {
764     bool WasInteresting = isInterestingIdentifier(*II);
765     II->setIsFromAST();
766     if (WasInteresting)
767       II->setChangedSinceDeserialization();
768   }
769 
770   // Set or check the various bits in the IdentifierInfo structure.
771   // Token IDs are read-only.
772   if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
773     II->RevertTokenIDToIdentifier();
774   II->setObjCOrBuiltinID(ObjCOrBuiltinID);
775   assert(II->isExtensionToken() == ExtensionToken &&
776          "Incorrect extension token flag");
777   (void)ExtensionToken;
778   if (Poisoned)
779     II->setIsPoisoned(true);
780   assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
781          "Incorrect C++ operator keyword flag");
782   (void)CPlusPlusOperatorKeyword;
783 
784   // If this identifier is a macro, deserialize the macro
785   // definition.
786   if (hadMacroDefinition) {
787     uint32_t MacroDirectivesOffset =
788         endian::readNext<uint32_t, little, unaligned>(d);
789     DataLen -= 4;
790     SmallVector<uint32_t, 8> LocalMacroIDs;
791     if (hasSubmoduleMacros) {
792       while (true) {
793         uint32_t LocalMacroID =
794             endian::readNext<uint32_t, little, unaligned>(d);
795         DataLen -= 4;
796         if (LocalMacroID == 0xdeadbeef) break;
797         LocalMacroIDs.push_back(LocalMacroID);
798       }
799     }
800 
801     if (F.Kind == MK_ImplicitModule || F.Kind == MK_ExplicitModule) {
802       // Macro definitions are stored from newest to oldest, so reverse them
803       // before registering them.
804       llvm::SmallVector<unsigned, 8> MacroSizes;
805       for (SmallVectorImpl<uint32_t>::iterator
806              I = LocalMacroIDs.begin(), E = LocalMacroIDs.end(); I != E; /**/) {
807         unsigned Size = 1;
808 
809         static const uint32_t HasOverridesFlag = 0x80000000U;
810         if (I + 1 != E && (I[1] & HasOverridesFlag))
811           Size += 1 + (I[1] & ~HasOverridesFlag);
812 
813         MacroSizes.push_back(Size);
814         I += Size;
815       }
816 
817       SmallVectorImpl<uint32_t>::iterator I = LocalMacroIDs.end();
818       for (SmallVectorImpl<unsigned>::reverse_iterator SI = MacroSizes.rbegin(),
819                                                        SE = MacroSizes.rend();
820            SI != SE; ++SI) {
821         I -= *SI;
822 
823         uint32_t LocalMacroID = *I;
824         ArrayRef<uint32_t> Overrides;
825         if (*SI != 1)
826           Overrides = llvm::makeArrayRef(&I[2], *SI - 2);
827         Reader.addPendingMacroFromModule(II, &F, LocalMacroID, Overrides);
828       }
829       assert(I == LocalMacroIDs.begin());
830     } else {
831       Reader.addPendingMacroFromPCH(II, &F, MacroDirectivesOffset);
832     }
833   }
834 
835   Reader.SetIdentifierInfo(ID, II);
836 
837   // Read all of the declarations visible at global scope with this
838   // name.
839   if (DataLen > 0) {
840     SmallVector<uint32_t, 4> DeclIDs;
841     for (; DataLen > 0; DataLen -= 4)
842       DeclIDs.push_back(Reader.getGlobalDeclID(
843           F, endian::readNext<uint32_t, little, unaligned>(d)));
844     Reader.SetGloballyVisibleDecls(II, DeclIDs);
845   }
846 
847   return II;
848 }
849 
850 unsigned
851 ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const {
852   llvm::FoldingSetNodeID ID;
853   ID.AddInteger(Key.Kind);
854 
855   switch (Key.Kind) {
856   case DeclarationName::Identifier:
857   case DeclarationName::CXXLiteralOperatorName:
858     ID.AddString(((IdentifierInfo*)Key.Data)->getName());
859     break;
860   case DeclarationName::ObjCZeroArgSelector:
861   case DeclarationName::ObjCOneArgSelector:
862   case DeclarationName::ObjCMultiArgSelector:
863     ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
864     break;
865   case DeclarationName::CXXOperatorName:
866     ID.AddInteger((OverloadedOperatorKind)Key.Data);
867     break;
868   case DeclarationName::CXXConstructorName:
869   case DeclarationName::CXXDestructorName:
870   case DeclarationName::CXXConversionFunctionName:
871   case DeclarationName::CXXUsingDirective:
872     break;
873   }
874 
875   return ID.ComputeHash();
876 }
877 
878 ASTDeclContextNameLookupTrait::internal_key_type
879 ASTDeclContextNameLookupTrait::GetInternalKey(
880                                           const external_key_type& Name) const {
881   DeclNameKey Key;
882   Key.Kind = Name.getNameKind();
883   switch (Name.getNameKind()) {
884   case DeclarationName::Identifier:
885     Key.Data = (uint64_t)Name.getAsIdentifierInfo();
886     break;
887   case DeclarationName::ObjCZeroArgSelector:
888   case DeclarationName::ObjCOneArgSelector:
889   case DeclarationName::ObjCMultiArgSelector:
890     Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
891     break;
892   case DeclarationName::CXXOperatorName:
893     Key.Data = Name.getCXXOverloadedOperator();
894     break;
895   case DeclarationName::CXXLiteralOperatorName:
896     Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
897     break;
898   case DeclarationName::CXXConstructorName:
899   case DeclarationName::CXXDestructorName:
900   case DeclarationName::CXXConversionFunctionName:
901   case DeclarationName::CXXUsingDirective:
902     Key.Data = 0;
903     break;
904   }
905 
906   return Key;
907 }
908 
909 std::pair<unsigned, unsigned>
910 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
911   using namespace llvm::support;
912   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
913   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
914   return std::make_pair(KeyLen, DataLen);
915 }
916 
917 ASTDeclContextNameLookupTrait::internal_key_type
918 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) {
919   using namespace llvm::support;
920 
921   DeclNameKey Key;
922   Key.Kind = (DeclarationName::NameKind)*d++;
923   switch (Key.Kind) {
924   case DeclarationName::Identifier:
925     Key.Data = (uint64_t)Reader.getLocalIdentifier(
926         F, endian::readNext<uint32_t, little, unaligned>(d));
927     break;
928   case DeclarationName::ObjCZeroArgSelector:
929   case DeclarationName::ObjCOneArgSelector:
930   case DeclarationName::ObjCMultiArgSelector:
931     Key.Data =
932         (uint64_t)Reader.getLocalSelector(
933                              F, endian::readNext<uint32_t, little, unaligned>(
934                                     d)).getAsOpaquePtr();
935     break;
936   case DeclarationName::CXXOperatorName:
937     Key.Data = *d++; // OverloadedOperatorKind
938     break;
939   case DeclarationName::CXXLiteralOperatorName:
940     Key.Data = (uint64_t)Reader.getLocalIdentifier(
941         F, endian::readNext<uint32_t, little, unaligned>(d));
942     break;
943   case DeclarationName::CXXConstructorName:
944   case DeclarationName::CXXDestructorName:
945   case DeclarationName::CXXConversionFunctionName:
946   case DeclarationName::CXXUsingDirective:
947     Key.Data = 0;
948     break;
949   }
950 
951   return Key;
952 }
953 
954 ASTDeclContextNameLookupTrait::data_type
955 ASTDeclContextNameLookupTrait::ReadData(internal_key_type,
956                                         const unsigned char* d,
957                                         unsigned DataLen) {
958   using namespace llvm::support;
959   unsigned NumDecls = endian::readNext<uint16_t, little, unaligned>(d);
960   LE32DeclID *Start = reinterpret_cast<LE32DeclID *>(
961                         const_cast<unsigned char *>(d));
962   return std::make_pair(Start, Start + NumDecls);
963 }
964 
965 bool ASTReader::ReadDeclContextStorage(ModuleFile &M,
966                                        BitstreamCursor &Cursor,
967                                    const std::pair<uint64_t, uint64_t> &Offsets,
968                                        DeclContextInfo &Info) {
969   SavedStreamPosition SavedPosition(Cursor);
970   // First the lexical decls.
971   if (Offsets.first != 0) {
972     Cursor.JumpToBit(Offsets.first);
973 
974     RecordData Record;
975     StringRef Blob;
976     unsigned Code = Cursor.ReadCode();
977     unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
978     if (RecCode != DECL_CONTEXT_LEXICAL) {
979       Error("Expected lexical block");
980       return true;
981     }
982 
983     Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob.data());
984     Info.NumLexicalDecls = Blob.size() / sizeof(KindDeclIDPair);
985   }
986 
987   // Now the lookup table.
988   if (Offsets.second != 0) {
989     Cursor.JumpToBit(Offsets.second);
990 
991     RecordData Record;
992     StringRef Blob;
993     unsigned Code = Cursor.ReadCode();
994     unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
995     if (RecCode != DECL_CONTEXT_VISIBLE) {
996       Error("Expected visible lookup table block");
997       return true;
998     }
999     Info.NameLookupTableData = ASTDeclContextNameLookupTable::Create(
1000         (const unsigned char *)Blob.data() + Record[0],
1001         (const unsigned char *)Blob.data() + sizeof(uint32_t),
1002         (const unsigned char *)Blob.data(),
1003         ASTDeclContextNameLookupTrait(*this, M));
1004   }
1005 
1006   return false;
1007 }
1008 
1009 void ASTReader::Error(StringRef Msg) {
1010   Error(diag::err_fe_pch_malformed, Msg);
1011   if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight()) {
1012     Diag(diag::note_module_cache_path)
1013       << PP.getHeaderSearchInfo().getModuleCachePath();
1014   }
1015 }
1016 
1017 void ASTReader::Error(unsigned DiagID,
1018                       StringRef Arg1, StringRef Arg2) {
1019   if (Diags.isDiagnosticInFlight())
1020     Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1021   else
1022     Diag(DiagID) << Arg1 << Arg2;
1023 }
1024 
1025 //===----------------------------------------------------------------------===//
1026 // Source Manager Deserialization
1027 //===----------------------------------------------------------------------===//
1028 
1029 /// \brief Read the line table in the source manager block.
1030 /// \returns true if there was an error.
1031 bool ASTReader::ParseLineTable(ModuleFile &F,
1032                                SmallVectorImpl<uint64_t> &Record) {
1033   unsigned Idx = 0;
1034   LineTableInfo &LineTable = SourceMgr.getLineTable();
1035 
1036   // Parse the file names
1037   std::map<int, int> FileIDs;
1038   for (int I = 0, N = Record[Idx++]; I != N; ++I) {
1039     // Extract the file name
1040     unsigned FilenameLen = Record[Idx++];
1041     std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
1042     Idx += FilenameLen;
1043     MaybeAddSystemRootToFilename(F, Filename);
1044     FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1045   }
1046 
1047   // Parse the line entries
1048   std::vector<LineEntry> Entries;
1049   while (Idx < Record.size()) {
1050     int FID = Record[Idx++];
1051     assert(FID >= 0 && "Serialized line entries for non-local file.");
1052     // Remap FileID from 1-based old view.
1053     FID += F.SLocEntryBaseID - 1;
1054 
1055     // Extract the line entries
1056     unsigned NumEntries = Record[Idx++];
1057     assert(NumEntries && "Numentries is 00000");
1058     Entries.clear();
1059     Entries.reserve(NumEntries);
1060     for (unsigned I = 0; I != NumEntries; ++I) {
1061       unsigned FileOffset = Record[Idx++];
1062       unsigned LineNo = Record[Idx++];
1063       int FilenameID = FileIDs[Record[Idx++]];
1064       SrcMgr::CharacteristicKind FileKind
1065         = (SrcMgr::CharacteristicKind)Record[Idx++];
1066       unsigned IncludeOffset = Record[Idx++];
1067       Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1068                                        FileKind, IncludeOffset));
1069     }
1070     LineTable.AddEntry(FileID::get(FID), Entries);
1071   }
1072 
1073   return false;
1074 }
1075 
1076 /// \brief Read a source manager block
1077 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1078   using namespace SrcMgr;
1079 
1080   BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1081 
1082   // Set the source-location entry cursor to the current position in
1083   // the stream. This cursor will be used to read the contents of the
1084   // source manager block initially, and then lazily read
1085   // source-location entries as needed.
1086   SLocEntryCursor = F.Stream;
1087 
1088   // The stream itself is going to skip over the source manager block.
1089   if (F.Stream.SkipBlock()) {
1090     Error("malformed block record in AST file");
1091     return true;
1092   }
1093 
1094   // Enter the source manager block.
1095   if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1096     Error("malformed source manager block record in AST file");
1097     return true;
1098   }
1099 
1100   RecordData Record;
1101   while (true) {
1102     llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1103 
1104     switch (E.Kind) {
1105     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1106     case llvm::BitstreamEntry::Error:
1107       Error("malformed block record in AST file");
1108       return true;
1109     case llvm::BitstreamEntry::EndBlock:
1110       return false;
1111     case llvm::BitstreamEntry::Record:
1112       // The interesting case.
1113       break;
1114     }
1115 
1116     // Read a record.
1117     Record.clear();
1118     StringRef Blob;
1119     switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1120     default:  // Default behavior: ignore.
1121       break;
1122 
1123     case SM_SLOC_FILE_ENTRY:
1124     case SM_SLOC_BUFFER_ENTRY:
1125     case SM_SLOC_EXPANSION_ENTRY:
1126       // Once we hit one of the source location entries, we're done.
1127       return false;
1128     }
1129   }
1130 }
1131 
1132 /// \brief If a header file is not found at the path that we expect it to be
1133 /// and the PCH file was moved from its original location, try to resolve the
1134 /// file by assuming that header+PCH were moved together and the header is in
1135 /// the same place relative to the PCH.
1136 static std::string
1137 resolveFileRelativeToOriginalDir(const std::string &Filename,
1138                                  const std::string &OriginalDir,
1139                                  const std::string &CurrDir) {
1140   assert(OriginalDir != CurrDir &&
1141          "No point trying to resolve the file if the PCH dir didn't change");
1142   using namespace llvm::sys;
1143   SmallString<128> filePath(Filename);
1144   fs::make_absolute(filePath);
1145   assert(path::is_absolute(OriginalDir));
1146   SmallString<128> currPCHPath(CurrDir);
1147 
1148   path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1149                        fileDirE = path::end(path::parent_path(filePath));
1150   path::const_iterator origDirI = path::begin(OriginalDir),
1151                        origDirE = path::end(OriginalDir);
1152   // Skip the common path components from filePath and OriginalDir.
1153   while (fileDirI != fileDirE && origDirI != origDirE &&
1154          *fileDirI == *origDirI) {
1155     ++fileDirI;
1156     ++origDirI;
1157   }
1158   for (; origDirI != origDirE; ++origDirI)
1159     path::append(currPCHPath, "..");
1160   path::append(currPCHPath, fileDirI, fileDirE);
1161   path::append(currPCHPath, path::filename(Filename));
1162   return currPCHPath.str();
1163 }
1164 
1165 bool ASTReader::ReadSLocEntry(int ID) {
1166   if (ID == 0)
1167     return false;
1168 
1169   if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1170     Error("source location entry ID out-of-range for AST file");
1171     return true;
1172   }
1173 
1174   ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1175   F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1176   BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1177   unsigned BaseOffset = F->SLocEntryBaseOffset;
1178 
1179   ++NumSLocEntriesRead;
1180   llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1181   if (Entry.Kind != llvm::BitstreamEntry::Record) {
1182     Error("incorrectly-formatted source location entry in AST file");
1183     return true;
1184   }
1185 
1186   RecordData Record;
1187   StringRef Blob;
1188   switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1189   default:
1190     Error("incorrectly-formatted source location entry in AST file");
1191     return true;
1192 
1193   case SM_SLOC_FILE_ENTRY: {
1194     // We will detect whether a file changed and return 'Failure' for it, but
1195     // we will also try to fail gracefully by setting up the SLocEntry.
1196     unsigned InputID = Record[4];
1197     InputFile IF = getInputFile(*F, InputID);
1198     const FileEntry *File = IF.getFile();
1199     bool OverriddenBuffer = IF.isOverridden();
1200 
1201     // Note that we only check if a File was returned. If it was out-of-date
1202     // we have complained but we will continue creating a FileID to recover
1203     // gracefully.
1204     if (!File)
1205       return true;
1206 
1207     SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1208     if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1209       // This is the module's main file.
1210       IncludeLoc = getImportLocation(F);
1211     }
1212     SrcMgr::CharacteristicKind
1213       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1214     FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1215                                         ID, BaseOffset + Record[0]);
1216     SrcMgr::FileInfo &FileInfo =
1217           const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1218     FileInfo.NumCreatedFIDs = Record[5];
1219     if (Record[3])
1220       FileInfo.setHasLineDirectives();
1221 
1222     const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1223     unsigned NumFileDecls = Record[7];
1224     if (NumFileDecls) {
1225       assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1226       FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1227                                                              NumFileDecls));
1228     }
1229 
1230     const SrcMgr::ContentCache *ContentCache
1231       = SourceMgr.getOrCreateContentCache(File,
1232                               /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
1233     if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1234         ContentCache->ContentsEntry == ContentCache->OrigEntry) {
1235       unsigned Code = SLocEntryCursor.ReadCode();
1236       Record.clear();
1237       unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1238 
1239       if (RecCode != SM_SLOC_BUFFER_BLOB) {
1240         Error("AST record has invalid code");
1241         return true;
1242       }
1243 
1244       std::unique_ptr<llvm::MemoryBuffer> Buffer
1245         = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName());
1246       SourceMgr.overrideFileContents(File, std::move(Buffer));
1247     }
1248 
1249     break;
1250   }
1251 
1252   case SM_SLOC_BUFFER_ENTRY: {
1253     const char *Name = Blob.data();
1254     unsigned Offset = Record[0];
1255     SrcMgr::CharacteristicKind
1256       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1257     SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1258     if (IncludeLoc.isInvalid() &&
1259         (F->Kind == MK_ImplicitModule || F->Kind == MK_ExplicitModule)) {
1260       IncludeLoc = getImportLocation(F);
1261     }
1262     unsigned Code = SLocEntryCursor.ReadCode();
1263     Record.clear();
1264     unsigned RecCode
1265       = SLocEntryCursor.readRecord(Code, Record, &Blob);
1266 
1267     if (RecCode != SM_SLOC_BUFFER_BLOB) {
1268       Error("AST record has invalid code");
1269       return true;
1270     }
1271 
1272     std::unique_ptr<llvm::MemoryBuffer> Buffer =
1273         llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name);
1274     SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1275                            BaseOffset + Offset, IncludeLoc);
1276     break;
1277   }
1278 
1279   case SM_SLOC_EXPANSION_ENTRY: {
1280     SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1281     SourceMgr.createExpansionLoc(SpellingLoc,
1282                                      ReadSourceLocation(*F, Record[2]),
1283                                      ReadSourceLocation(*F, Record[3]),
1284                                      Record[4],
1285                                      ID,
1286                                      BaseOffset + Record[0]);
1287     break;
1288   }
1289   }
1290 
1291   return false;
1292 }
1293 
1294 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1295   if (ID == 0)
1296     return std::make_pair(SourceLocation(), "");
1297 
1298   if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1299     Error("source location entry ID out-of-range for AST file");
1300     return std::make_pair(SourceLocation(), "");
1301   }
1302 
1303   // Find which module file this entry lands in.
1304   ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1305   if (M->Kind != MK_ImplicitModule && M->Kind != MK_ExplicitModule)
1306     return std::make_pair(SourceLocation(), "");
1307 
1308   // FIXME: Can we map this down to a particular submodule? That would be
1309   // ideal.
1310   return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1311 }
1312 
1313 /// \brief Find the location where the module F is imported.
1314 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1315   if (F->ImportLoc.isValid())
1316     return F->ImportLoc;
1317 
1318   // Otherwise we have a PCH. It's considered to be "imported" at the first
1319   // location of its includer.
1320   if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1321     // Main file is the importer.
1322     assert(!SourceMgr.getMainFileID().isInvalid() && "missing main file");
1323     return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1324   }
1325   return F->ImportedBy[0]->FirstLoc;
1326 }
1327 
1328 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1329 /// specified cursor.  Read the abbreviations that are at the top of the block
1330 /// and then leave the cursor pointing into the block.
1331 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1332   if (Cursor.EnterSubBlock(BlockID)) {
1333     Error("malformed block record in AST file");
1334     return Failure;
1335   }
1336 
1337   while (true) {
1338     uint64_t Offset = Cursor.GetCurrentBitNo();
1339     unsigned Code = Cursor.ReadCode();
1340 
1341     // We expect all abbrevs to be at the start of the block.
1342     if (Code != llvm::bitc::DEFINE_ABBREV) {
1343       Cursor.JumpToBit(Offset);
1344       return false;
1345     }
1346     Cursor.ReadAbbrevRecord();
1347   }
1348 }
1349 
1350 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1351                            unsigned &Idx) {
1352   Token Tok;
1353   Tok.startToken();
1354   Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1355   Tok.setLength(Record[Idx++]);
1356   if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1357     Tok.setIdentifierInfo(II);
1358   Tok.setKind((tok::TokenKind)Record[Idx++]);
1359   Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1360   return Tok;
1361 }
1362 
1363 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1364   BitstreamCursor &Stream = F.MacroCursor;
1365 
1366   // Keep track of where we are in the stream, then jump back there
1367   // after reading this macro.
1368   SavedStreamPosition SavedPosition(Stream);
1369 
1370   Stream.JumpToBit(Offset);
1371   RecordData Record;
1372   SmallVector<IdentifierInfo*, 16> MacroArgs;
1373   MacroInfo *Macro = nullptr;
1374 
1375   while (true) {
1376     // Advance to the next record, but if we get to the end of the block, don't
1377     // pop it (removing all the abbreviations from the cursor) since we want to
1378     // be able to reseek within the block and read entries.
1379     unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1380     llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1381 
1382     switch (Entry.Kind) {
1383     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1384     case llvm::BitstreamEntry::Error:
1385       Error("malformed block record in AST file");
1386       return Macro;
1387     case llvm::BitstreamEntry::EndBlock:
1388       return Macro;
1389     case llvm::BitstreamEntry::Record:
1390       // The interesting case.
1391       break;
1392     }
1393 
1394     // Read a record.
1395     Record.clear();
1396     PreprocessorRecordTypes RecType =
1397       (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1398     switch (RecType) {
1399     case PP_MACRO_DIRECTIVE_HISTORY:
1400       return Macro;
1401 
1402     case PP_MACRO_OBJECT_LIKE:
1403     case PP_MACRO_FUNCTION_LIKE: {
1404       // If we already have a macro, that means that we've hit the end
1405       // of the definition of the macro we were looking for. We're
1406       // done.
1407       if (Macro)
1408         return Macro;
1409 
1410       unsigned NextIndex = 1; // Skip identifier ID.
1411       SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]);
1412       SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1413       MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID);
1414       MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1415       MI->setIsUsed(Record[NextIndex++]);
1416       MI->setUsedForHeaderGuard(Record[NextIndex++]);
1417 
1418       if (RecType == PP_MACRO_FUNCTION_LIKE) {
1419         // Decode function-like macro info.
1420         bool isC99VarArgs = Record[NextIndex++];
1421         bool isGNUVarArgs = Record[NextIndex++];
1422         bool hasCommaPasting = Record[NextIndex++];
1423         MacroArgs.clear();
1424         unsigned NumArgs = Record[NextIndex++];
1425         for (unsigned i = 0; i != NumArgs; ++i)
1426           MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1427 
1428         // Install function-like macro info.
1429         MI->setIsFunctionLike();
1430         if (isC99VarArgs) MI->setIsC99Varargs();
1431         if (isGNUVarArgs) MI->setIsGNUVarargs();
1432         if (hasCommaPasting) MI->setHasCommaPasting();
1433         MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
1434                             PP.getPreprocessorAllocator());
1435       }
1436 
1437       // Remember that we saw this macro last so that we add the tokens that
1438       // form its body to it.
1439       Macro = MI;
1440 
1441       if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1442           Record[NextIndex]) {
1443         // We have a macro definition. Register the association
1444         PreprocessedEntityID
1445             GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1446         PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1447         PreprocessingRecord::PPEntityID
1448           PPID = PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true);
1449         MacroDefinition *PPDef =
1450           cast_or_null<MacroDefinition>(PPRec.getPreprocessedEntity(PPID));
1451         if (PPDef)
1452           PPRec.RegisterMacroDefinition(Macro, PPDef);
1453       }
1454 
1455       ++NumMacrosRead;
1456       break;
1457     }
1458 
1459     case PP_TOKEN: {
1460       // If we see a TOKEN before a PP_MACRO_*, then the file is
1461       // erroneous, just pretend we didn't see this.
1462       if (!Macro) break;
1463 
1464       unsigned Idx = 0;
1465       Token Tok = ReadToken(F, Record, Idx);
1466       Macro->AddTokenToBody(Tok);
1467       break;
1468     }
1469     }
1470   }
1471 }
1472 
1473 PreprocessedEntityID
1474 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
1475   ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1476     I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1477   assert(I != M.PreprocessedEntityRemap.end()
1478          && "Invalid index into preprocessed entity index remap");
1479 
1480   return LocalID + I->second;
1481 }
1482 
1483 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1484   return llvm::hash_combine(ikey.Size, ikey.ModTime);
1485 }
1486 
1487 HeaderFileInfoTrait::internal_key_type
1488 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1489   internal_key_type ikey = { FE->getSize(), FE->getModificationTime(),
1490                              FE->getName() };
1491   return ikey;
1492 }
1493 
1494 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1495   if (a.Size != b.Size || a.ModTime != b.ModTime)
1496     return false;
1497 
1498   if (strcmp(a.Filename, b.Filename) == 0)
1499     return true;
1500 
1501   // Determine whether the actual files are equivalent.
1502   FileManager &FileMgr = Reader.getFileManager();
1503   const FileEntry *FEA = FileMgr.getFile(a.Filename);
1504   const FileEntry *FEB = FileMgr.getFile(b.Filename);
1505   return (FEA && FEA == FEB);
1506 }
1507 
1508 std::pair<unsigned, unsigned>
1509 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1510   using namespace llvm::support;
1511   unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1512   unsigned DataLen = (unsigned) *d++;
1513   return std::make_pair(KeyLen, DataLen);
1514 }
1515 
1516 HeaderFileInfoTrait::internal_key_type
1517 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1518   using namespace llvm::support;
1519   internal_key_type ikey;
1520   ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1521   ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1522   ikey.Filename = (const char *)d;
1523   return ikey;
1524 }
1525 
1526 HeaderFileInfoTrait::data_type
1527 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1528                               unsigned DataLen) {
1529   const unsigned char *End = d + DataLen;
1530   using namespace llvm::support;
1531   HeaderFileInfo HFI;
1532   unsigned Flags = *d++;
1533   HFI.HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>
1534                    ((Flags >> 6) & 0x03);
1535   HFI.isImport = (Flags >> 5) & 0x01;
1536   HFI.isPragmaOnce = (Flags >> 4) & 0x01;
1537   HFI.DirInfo = (Flags >> 2) & 0x03;
1538   HFI.Resolved = (Flags >> 1) & 0x01;
1539   HFI.IndexHeaderMapHeader = Flags & 0x01;
1540   HFI.NumIncludes = endian::readNext<uint16_t, little, unaligned>(d);
1541   HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1542       M, endian::readNext<uint32_t, little, unaligned>(d));
1543   if (unsigned FrameworkOffset =
1544           endian::readNext<uint32_t, little, unaligned>(d)) {
1545     // The framework offset is 1 greater than the actual offset,
1546     // since 0 is used as an indicator for "no framework name".
1547     StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1548     HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1549   }
1550 
1551   if (d != End) {
1552     uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1553     if (LocalSMID) {
1554       // This header is part of a module. Associate it with the module to enable
1555       // implicit module import.
1556       SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1557       Module *Mod = Reader.getSubmodule(GlobalSMID);
1558       HFI.isModuleHeader = true;
1559       FileManager &FileMgr = Reader.getFileManager();
1560       ModuleMap &ModMap =
1561           Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1562       ModMap.addHeader(Mod, FileMgr.getFile(key.Filename), HFI.getHeaderRole());
1563     }
1564   }
1565 
1566   assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1567   (void)End;
1568 
1569   // This HeaderFileInfo was externally loaded.
1570   HFI.External = true;
1571   return HFI;
1572 }
1573 
1574 void
1575 ASTReader::addPendingMacroFromModule(IdentifierInfo *II, ModuleFile *M,
1576                                      GlobalMacroID GMacID,
1577                                      ArrayRef<SubmoduleID> Overrides) {
1578   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1579   SubmoduleID *OverrideData = nullptr;
1580   if (!Overrides.empty()) {
1581     OverrideData = new (Context) SubmoduleID[Overrides.size() + 1];
1582     OverrideData[0] = Overrides.size();
1583     for (unsigned I = 0; I != Overrides.size(); ++I)
1584       OverrideData[I + 1] = getGlobalSubmoduleID(*M, Overrides[I]);
1585   }
1586   PendingMacroIDs[II].push_back(PendingMacroInfo(M, GMacID, OverrideData));
1587 }
1588 
1589 void ASTReader::addPendingMacroFromPCH(IdentifierInfo *II,
1590                                        ModuleFile *M,
1591                                        uint64_t MacroDirectivesOffset) {
1592   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1593   PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1594 }
1595 
1596 void ASTReader::ReadDefinedMacros() {
1597   // Note that we are loading defined macros.
1598   Deserializing Macros(this);
1599 
1600   for (ModuleReverseIterator I = ModuleMgr.rbegin(),
1601       E = ModuleMgr.rend(); I != E; ++I) {
1602     BitstreamCursor &MacroCursor = (*I)->MacroCursor;
1603 
1604     // If there was no preprocessor block, skip this file.
1605     if (!MacroCursor.getBitStreamReader())
1606       continue;
1607 
1608     BitstreamCursor Cursor = MacroCursor;
1609     Cursor.JumpToBit((*I)->MacroStartOffset);
1610 
1611     RecordData Record;
1612     while (true) {
1613       llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1614 
1615       switch (E.Kind) {
1616       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1617       case llvm::BitstreamEntry::Error:
1618         Error("malformed block record in AST file");
1619         return;
1620       case llvm::BitstreamEntry::EndBlock:
1621         goto NextCursor;
1622 
1623       case llvm::BitstreamEntry::Record:
1624         Record.clear();
1625         switch (Cursor.readRecord(E.ID, Record)) {
1626         default:  // Default behavior: ignore.
1627           break;
1628 
1629         case PP_MACRO_OBJECT_LIKE:
1630         case PP_MACRO_FUNCTION_LIKE:
1631           getLocalIdentifier(**I, Record[0]);
1632           break;
1633 
1634         case PP_TOKEN:
1635           // Ignore tokens.
1636           break;
1637         }
1638         break;
1639       }
1640     }
1641     NextCursor:  ;
1642   }
1643 }
1644 
1645 namespace {
1646   /// \brief Visitor class used to look up identifirs in an AST file.
1647   class IdentifierLookupVisitor {
1648     StringRef Name;
1649     unsigned PriorGeneration;
1650     unsigned &NumIdentifierLookups;
1651     unsigned &NumIdentifierLookupHits;
1652     IdentifierInfo *Found;
1653 
1654   public:
1655     IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1656                             unsigned &NumIdentifierLookups,
1657                             unsigned &NumIdentifierLookupHits)
1658       : Name(Name), PriorGeneration(PriorGeneration),
1659         NumIdentifierLookups(NumIdentifierLookups),
1660         NumIdentifierLookupHits(NumIdentifierLookupHits),
1661         Found()
1662     {
1663     }
1664 
1665     static bool visit(ModuleFile &M, void *UserData) {
1666       IdentifierLookupVisitor *This
1667         = static_cast<IdentifierLookupVisitor *>(UserData);
1668 
1669       // If we've already searched this module file, skip it now.
1670       if (M.Generation <= This->PriorGeneration)
1671         return true;
1672 
1673       ASTIdentifierLookupTable *IdTable
1674         = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1675       if (!IdTable)
1676         return false;
1677 
1678       ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(),
1679                                      M, This->Found);
1680       ++This->NumIdentifierLookups;
1681       ASTIdentifierLookupTable::iterator Pos = IdTable->find(This->Name,&Trait);
1682       if (Pos == IdTable->end())
1683         return false;
1684 
1685       // Dereferencing the iterator has the effect of building the
1686       // IdentifierInfo node and populating it with the various
1687       // declarations it needs.
1688       ++This->NumIdentifierLookupHits;
1689       This->Found = *Pos;
1690       return true;
1691     }
1692 
1693     // \brief Retrieve the identifier info found within the module
1694     // files.
1695     IdentifierInfo *getIdentifierInfo() const { return Found; }
1696   };
1697 }
1698 
1699 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1700   // Note that we are loading an identifier.
1701   Deserializing AnIdentifier(this);
1702 
1703   unsigned PriorGeneration = 0;
1704   if (getContext().getLangOpts().Modules)
1705     PriorGeneration = IdentifierGeneration[&II];
1706 
1707   // If there is a global index, look there first to determine which modules
1708   // provably do not have any results for this identifier.
1709   GlobalModuleIndex::HitSet Hits;
1710   GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1711   if (!loadGlobalIndex()) {
1712     if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1713       HitsPtr = &Hits;
1714     }
1715   }
1716 
1717   IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1718                                   NumIdentifierLookups,
1719                                   NumIdentifierLookupHits);
1720   ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr);
1721   markIdentifierUpToDate(&II);
1722 }
1723 
1724 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1725   if (!II)
1726     return;
1727 
1728   II->setOutOfDate(false);
1729 
1730   // Update the generation for this identifier.
1731   if (getContext().getLangOpts().Modules)
1732     IdentifierGeneration[II] = getGeneration();
1733 }
1734 
1735 struct ASTReader::ModuleMacroInfo {
1736   SubmoduleID SubModID;
1737   MacroInfo *MI;
1738   SubmoduleID *Overrides;
1739   // FIXME: Remove this.
1740   ModuleFile *F;
1741 
1742   bool isDefine() const { return MI; }
1743 
1744   SubmoduleID getSubmoduleID() const { return SubModID; }
1745 
1746   ArrayRef<SubmoduleID> getOverriddenSubmodules() const {
1747     if (!Overrides)
1748       return None;
1749     return llvm::makeArrayRef(Overrides + 1, *Overrides);
1750   }
1751 
1752   MacroDirective *import(Preprocessor &PP, SourceLocation ImportLoc) const {
1753     if (!MI)
1754       return PP.AllocateUndefMacroDirective(ImportLoc, SubModID,
1755                                             getOverriddenSubmodules());
1756     return PP.AllocateDefMacroDirective(MI, ImportLoc, SubModID,
1757                                         getOverriddenSubmodules());
1758   }
1759 };
1760 
1761 ASTReader::ModuleMacroInfo *
1762 ASTReader::getModuleMacro(const PendingMacroInfo &PMInfo) {
1763   ModuleMacroInfo Info;
1764 
1765   uint32_t ID = PMInfo.ModuleMacroData.MacID;
1766   if (ID & 1) {
1767     // Macro undefinition.
1768     Info.SubModID = getGlobalSubmoduleID(*PMInfo.M, ID >> 1);
1769     Info.MI = nullptr;
1770   } else {
1771     // Macro definition.
1772     GlobalMacroID GMacID = getGlobalMacroID(*PMInfo.M, ID >> 1);
1773     assert(GMacID);
1774 
1775     // If this macro has already been loaded, don't do so again.
1776     // FIXME: This is highly dubious. Multiple macro definitions can have the
1777     // same MacroInfo (and hence the same GMacID) due to #pragma push_macro etc.
1778     if (MacrosLoaded[GMacID - NUM_PREDEF_MACRO_IDS])
1779       return nullptr;
1780 
1781     Info.MI = getMacro(GMacID);
1782     Info.SubModID = Info.MI->getOwningModuleID();
1783   }
1784   Info.Overrides = PMInfo.ModuleMacroData.Overrides;
1785   Info.F = PMInfo.M;
1786 
1787   return new (Context) ModuleMacroInfo(Info);
1788 }
1789 
1790 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1791                                     const PendingMacroInfo &PMInfo) {
1792   assert(II);
1793 
1794   if (PMInfo.M->Kind != MK_ImplicitModule &&
1795       PMInfo.M->Kind != MK_ExplicitModule) {
1796     installPCHMacroDirectives(II, *PMInfo.M,
1797                               PMInfo.PCHMacroData.MacroDirectivesOffset);
1798     return;
1799   }
1800 
1801   // Module Macro.
1802 
1803   ModuleMacroInfo *MMI = getModuleMacro(PMInfo);
1804   if (!MMI)
1805     return;
1806 
1807   Module *Owner = getSubmodule(MMI->getSubmoduleID());
1808   if (Owner && Owner->NameVisibility == Module::Hidden) {
1809     // Macros in the owning module are hidden. Just remember this macro to
1810     // install if we make this module visible.
1811     HiddenNamesMap[Owner].HiddenMacros.insert(std::make_pair(II, MMI));
1812   } else {
1813     installImportedMacro(II, MMI, Owner);
1814   }
1815 }
1816 
1817 void ASTReader::installPCHMacroDirectives(IdentifierInfo *II,
1818                                           ModuleFile &M, uint64_t Offset) {
1819   assert(M.Kind != MK_ImplicitModule && M.Kind != MK_ExplicitModule);
1820 
1821   BitstreamCursor &Cursor = M.MacroCursor;
1822   SavedStreamPosition SavedPosition(Cursor);
1823   Cursor.JumpToBit(Offset);
1824 
1825   llvm::BitstreamEntry Entry =
1826       Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1827   if (Entry.Kind != llvm::BitstreamEntry::Record) {
1828     Error("malformed block record in AST file");
1829     return;
1830   }
1831 
1832   RecordData Record;
1833   PreprocessorRecordTypes RecType =
1834     (PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record);
1835   if (RecType != PP_MACRO_DIRECTIVE_HISTORY) {
1836     Error("malformed block record in AST file");
1837     return;
1838   }
1839 
1840   // Deserialize the macro directives history in reverse source-order.
1841   MacroDirective *Latest = nullptr, *Earliest = nullptr;
1842   unsigned Idx = 0, N = Record.size();
1843   while (Idx < N) {
1844     MacroDirective *MD = nullptr;
1845     SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
1846     MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
1847     switch (K) {
1848     case MacroDirective::MD_Define: {
1849       GlobalMacroID GMacID = getGlobalMacroID(M, Record[Idx++]);
1850       MacroInfo *MI = getMacro(GMacID);
1851       SubmoduleID ImportedFrom = Record[Idx++];
1852       bool IsAmbiguous = Record[Idx++];
1853       llvm::SmallVector<unsigned, 4> Overrides;
1854       if (ImportedFrom) {
1855         Overrides.insert(Overrides.end(),
1856                          &Record[Idx] + 1, &Record[Idx] + 1 + Record[Idx]);
1857         Idx += Overrides.size() + 1;
1858       }
1859       DefMacroDirective *DefMD =
1860           PP.AllocateDefMacroDirective(MI, Loc, ImportedFrom, Overrides);
1861       DefMD->setAmbiguous(IsAmbiguous);
1862       MD = DefMD;
1863       break;
1864     }
1865     case MacroDirective::MD_Undefine: {
1866       SubmoduleID ImportedFrom = Record[Idx++];
1867       llvm::SmallVector<unsigned, 4> Overrides;
1868       if (ImportedFrom) {
1869         Overrides.insert(Overrides.end(),
1870                          &Record[Idx] + 1, &Record[Idx] + 1 + Record[Idx]);
1871         Idx += Overrides.size() + 1;
1872       }
1873       MD = PP.AllocateUndefMacroDirective(Loc, ImportedFrom, Overrides);
1874       break;
1875     }
1876     case MacroDirective::MD_Visibility:
1877       bool isPublic = Record[Idx++];
1878       MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
1879       break;
1880     }
1881 
1882     if (!Latest)
1883       Latest = MD;
1884     if (Earliest)
1885       Earliest->setPrevious(MD);
1886     Earliest = MD;
1887   }
1888 
1889   PP.setLoadedMacroDirective(II, Latest);
1890 }
1891 
1892 /// \brief For the given macro definitions, check if they are both in system
1893 /// modules.
1894 static bool areDefinedInSystemModules(MacroInfo *PrevMI, MacroInfo *NewMI,
1895                                       Module *NewOwner, ASTReader &Reader) {
1896   assert(PrevMI && NewMI);
1897   Module *PrevOwner = nullptr;
1898   if (SubmoduleID PrevModID = PrevMI->getOwningModuleID())
1899     PrevOwner = Reader.getSubmodule(PrevModID);
1900   SourceManager &SrcMgr = Reader.getSourceManager();
1901   bool PrevInSystem
1902     = PrevOwner? PrevOwner->IsSystem
1903                : SrcMgr.isInSystemHeader(PrevMI->getDefinitionLoc());
1904   bool NewInSystem
1905     = NewOwner? NewOwner->IsSystem
1906               : SrcMgr.isInSystemHeader(NewMI->getDefinitionLoc());
1907   if (PrevOwner && PrevOwner == NewOwner)
1908     return false;
1909   return PrevInSystem && NewInSystem;
1910 }
1911 
1912 void ASTReader::removeOverriddenMacros(IdentifierInfo *II,
1913                                        SourceLocation ImportLoc,
1914                                        AmbiguousMacros &Ambig,
1915                                        ArrayRef<SubmoduleID> Overrides) {
1916   for (unsigned OI = 0, ON = Overrides.size(); OI != ON; ++OI) {
1917     SubmoduleID OwnerID = Overrides[OI];
1918 
1919     // If this macro is not yet visible, remove it from the hidden names list.
1920     // It won't be there if we're in the middle of making the owner visible.
1921     Module *Owner = getSubmodule(OwnerID);
1922     auto HiddenIt = HiddenNamesMap.find(Owner);
1923     if (HiddenIt != HiddenNamesMap.end()) {
1924       HiddenNames &Hidden = HiddenIt->second;
1925       HiddenMacrosMap::iterator HI = Hidden.HiddenMacros.find(II);
1926       if (HI != Hidden.HiddenMacros.end()) {
1927         // Register the macro now so we don't lose it when we re-export.
1928         PP.appendMacroDirective(II, HI->second->import(PP, ImportLoc));
1929 
1930         auto SubOverrides = HI->second->getOverriddenSubmodules();
1931         Hidden.HiddenMacros.erase(HI);
1932         removeOverriddenMacros(II, ImportLoc, Ambig, SubOverrides);
1933       }
1934     }
1935 
1936     // If this macro is already in our list of conflicts, remove it from there.
1937     Ambig.erase(
1938         std::remove_if(Ambig.begin(), Ambig.end(), [&](DefMacroDirective *MD) {
1939           return MD->getInfo()->getOwningModuleID() == OwnerID;
1940         }),
1941         Ambig.end());
1942   }
1943 }
1944 
1945 ASTReader::AmbiguousMacros *
1946 ASTReader::removeOverriddenMacros(IdentifierInfo *II,
1947                                   SourceLocation ImportLoc,
1948                                   ArrayRef<SubmoduleID> Overrides) {
1949   MacroDirective *Prev = PP.getMacroDirective(II);
1950   if (!Prev && Overrides.empty())
1951     return nullptr;
1952 
1953   DefMacroDirective *PrevDef = Prev ? Prev->getDefinition().getDirective()
1954                                     : nullptr;
1955   if (PrevDef && PrevDef->isAmbiguous()) {
1956     // We had a prior ambiguity. Check whether we resolve it (or make it worse).
1957     AmbiguousMacros &Ambig = AmbiguousMacroDefs[II];
1958     Ambig.push_back(PrevDef);
1959 
1960     removeOverriddenMacros(II, ImportLoc, Ambig, Overrides);
1961 
1962     if (!Ambig.empty())
1963       return &Ambig;
1964 
1965     AmbiguousMacroDefs.erase(II);
1966   } else {
1967     // There's no ambiguity yet. Maybe we're introducing one.
1968     AmbiguousMacros Ambig;
1969     if (PrevDef)
1970       Ambig.push_back(PrevDef);
1971 
1972     removeOverriddenMacros(II, ImportLoc, Ambig, Overrides);
1973 
1974     if (!Ambig.empty()) {
1975       AmbiguousMacros &Result = AmbiguousMacroDefs[II];
1976       std::swap(Result, Ambig);
1977       return &Result;
1978     }
1979   }
1980 
1981   // We ended up with no ambiguity.
1982   return nullptr;
1983 }
1984 
1985 void ASTReader::installImportedMacro(IdentifierInfo *II, ModuleMacroInfo *MMI,
1986                                      Module *Owner) {
1987   assert(II && Owner);
1988 
1989   SourceLocation ImportLoc = Owner->MacroVisibilityLoc;
1990   if (ImportLoc.isInvalid()) {
1991     // FIXME: If we made macros from this module visible but didn't provide a
1992     // source location for the import, we don't have a location for the macro.
1993     // Use the location at which the containing module file was first imported
1994     // for now.
1995     ImportLoc = MMI->F->DirectImportLoc;
1996     assert(ImportLoc.isValid() && "no import location for a visible macro?");
1997   }
1998 
1999   AmbiguousMacros *Prev =
2000       removeOverriddenMacros(II, ImportLoc, MMI->getOverriddenSubmodules());
2001 
2002   // Create a synthetic macro definition corresponding to the import (or null
2003   // if this was an undefinition of the macro).
2004   MacroDirective *Imported = MMI->import(PP, ImportLoc);
2005   DefMacroDirective *MD = dyn_cast<DefMacroDirective>(Imported);
2006 
2007   // If there's no ambiguity, just install the macro.
2008   if (!Prev) {
2009     PP.appendMacroDirective(II, Imported);
2010     return;
2011   }
2012   assert(!Prev->empty());
2013 
2014   if (!MD) {
2015     // We imported a #undef that didn't remove all prior definitions. The most
2016     // recent prior definition remains, and we install it in the place of the
2017     // imported directive, as if by a local #pragma pop_macro.
2018     MacroInfo *NewMI = Prev->back()->getInfo();
2019     Prev->pop_back();
2020     MD = PP.AllocateDefMacroDirective(NewMI, ImportLoc);
2021 
2022     // Install our #undef first so that we don't lose track of it. We'll replace
2023     // this with whichever macro definition ends up winning.
2024     PP.appendMacroDirective(II, Imported);
2025   }
2026 
2027   // We're introducing a macro definition that creates or adds to an ambiguity.
2028   // We can resolve that ambiguity if this macro is token-for-token identical to
2029   // all of the existing definitions.
2030   MacroInfo *NewMI = MD->getInfo();
2031   assert(NewMI && "macro definition with no MacroInfo?");
2032   while (!Prev->empty()) {
2033     MacroInfo *PrevMI = Prev->back()->getInfo();
2034     assert(PrevMI && "macro definition with no MacroInfo?");
2035 
2036     // Before marking the macros as ambiguous, check if this is a case where
2037     // both macros are in system headers. If so, we trust that the system
2038     // did not get it wrong. This also handles cases where Clang's own
2039     // headers have a different spelling of certain system macros:
2040     //   #define LONG_MAX __LONG_MAX__ (clang's limits.h)
2041     //   #define LONG_MAX 0x7fffffffffffffffL (system's limits.h)
2042     //
2043     // FIXME: Remove the defined-in-system-headers check. clang's limits.h
2044     // overrides the system limits.h's macros, so there's no conflict here.
2045     if (NewMI != PrevMI &&
2046         !PrevMI->isIdenticalTo(*NewMI, PP, /*Syntactically=*/true) &&
2047         !areDefinedInSystemModules(PrevMI, NewMI, Owner, *this))
2048       break;
2049 
2050     // The previous definition is the same as this one (or both are defined in
2051     // system modules so we can assume they're equivalent); we don't need to
2052     // track it any more.
2053     Prev->pop_back();
2054   }
2055 
2056   if (!Prev->empty())
2057     MD->setAmbiguous(true);
2058 
2059   PP.appendMacroDirective(II, MD);
2060 }
2061 
2062 ASTReader::InputFileInfo
2063 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2064   // Go find this input file.
2065   BitstreamCursor &Cursor = F.InputFilesCursor;
2066   SavedStreamPosition SavedPosition(Cursor);
2067   Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2068 
2069   unsigned Code = Cursor.ReadCode();
2070   RecordData Record;
2071   StringRef Blob;
2072 
2073   unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2074   assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2075          "invalid record type for input file");
2076   (void)Result;
2077 
2078   std::string Filename;
2079   off_t StoredSize;
2080   time_t StoredTime;
2081   bool Overridden;
2082 
2083   assert(Record[0] == ID && "Bogus stored ID or offset");
2084   StoredSize = static_cast<off_t>(Record[1]);
2085   StoredTime = static_cast<time_t>(Record[2]);
2086   Overridden = static_cast<bool>(Record[3]);
2087   Filename = Blob;
2088   MaybeAddSystemRootToFilename(F, Filename);
2089 
2090   InputFileInfo R = { std::move(Filename), StoredSize, StoredTime, Overridden };
2091   return R;
2092 }
2093 
2094 std::string ASTReader::getInputFileName(ModuleFile &F, unsigned int ID) {
2095   return readInputFileInfo(F, ID).Filename;
2096 }
2097 
2098 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2099   // If this ID is bogus, just return an empty input file.
2100   if (ID == 0 || ID > F.InputFilesLoaded.size())
2101     return InputFile();
2102 
2103   // If we've already loaded this input file, return it.
2104   if (F.InputFilesLoaded[ID-1].getFile())
2105     return F.InputFilesLoaded[ID-1];
2106 
2107   if (F.InputFilesLoaded[ID-1].isNotFound())
2108     return InputFile();
2109 
2110   // Go find this input file.
2111   BitstreamCursor &Cursor = F.InputFilesCursor;
2112   SavedStreamPosition SavedPosition(Cursor);
2113   Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2114 
2115   InputFileInfo FI = readInputFileInfo(F, ID);
2116   off_t StoredSize = FI.StoredSize;
2117   time_t StoredTime = FI.StoredTime;
2118   bool Overridden = FI.Overridden;
2119   StringRef Filename = FI.Filename;
2120 
2121   const FileEntry *File
2122     = Overridden? FileMgr.getVirtualFile(Filename, StoredSize, StoredTime)
2123                 : FileMgr.getFile(Filename, /*OpenFile=*/false);
2124 
2125   // If we didn't find the file, resolve it relative to the
2126   // original directory from which this AST file was created.
2127   if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
2128       F.OriginalDir != CurrentDir) {
2129     std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
2130                                                             F.OriginalDir,
2131                                                             CurrentDir);
2132     if (!Resolved.empty())
2133       File = FileMgr.getFile(Resolved);
2134   }
2135 
2136   // For an overridden file, create a virtual file with the stored
2137   // size/timestamp.
2138   if (Overridden && File == nullptr) {
2139     File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2140   }
2141 
2142   if (File == nullptr) {
2143     if (Complain) {
2144       std::string ErrorStr = "could not find file '";
2145       ErrorStr += Filename;
2146       ErrorStr += "' referenced by AST file";
2147       Error(ErrorStr.c_str());
2148     }
2149     // Record that we didn't find the file.
2150     F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2151     return InputFile();
2152   }
2153 
2154   // Check if there was a request to override the contents of the file
2155   // that was part of the precompiled header. Overridding such a file
2156   // can lead to problems when lexing using the source locations from the
2157   // PCH.
2158   SourceManager &SM = getSourceManager();
2159   if (!Overridden && SM.isFileOverridden(File)) {
2160     if (Complain)
2161       Error(diag::err_fe_pch_file_overridden, Filename);
2162     // After emitting the diagnostic, recover by disabling the override so
2163     // that the original file will be used.
2164     SM.disableFileContentsOverride(File);
2165     // The FileEntry is a virtual file entry with the size of the contents
2166     // that would override the original contents. Set it to the original's
2167     // size/time.
2168     FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2169                             StoredSize, StoredTime);
2170   }
2171 
2172   bool IsOutOfDate = false;
2173 
2174   // For an overridden file, there is nothing to validate.
2175   if (!Overridden && //
2176       (StoredSize != File->getSize() ||
2177 #if defined(LLVM_ON_WIN32)
2178        false
2179 #else
2180        // In our regression testing, the Windows file system seems to
2181        // have inconsistent modification times that sometimes
2182        // erroneously trigger this error-handling path.
2183        //
2184        // This also happens in networked file systems, so disable this
2185        // check if validation is disabled or if we have an explicitly
2186        // built PCM file.
2187        //
2188        // FIXME: Should we also do this for PCH files? They could also
2189        // reasonably get shared across a network during a distributed build.
2190        (StoredTime != File->getModificationTime() && !DisableValidation &&
2191         F.Kind != MK_ExplicitModule)
2192 #endif
2193        )) {
2194     if (Complain) {
2195       // Build a list of the PCH imports that got us here (in reverse).
2196       SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2197       while (ImportStack.back()->ImportedBy.size() > 0)
2198         ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2199 
2200       // The top-level PCH is stale.
2201       StringRef TopLevelPCHName(ImportStack.back()->FileName);
2202       Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2203 
2204       // Print the import stack.
2205       if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2206         Diag(diag::note_pch_required_by)
2207           << Filename << ImportStack[0]->FileName;
2208         for (unsigned I = 1; I < ImportStack.size(); ++I)
2209           Diag(diag::note_pch_required_by)
2210             << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2211       }
2212 
2213       if (!Diags.isDiagnosticInFlight())
2214         Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2215     }
2216 
2217     IsOutOfDate = true;
2218   }
2219 
2220   InputFile IF = InputFile(File, Overridden, IsOutOfDate);
2221 
2222   // Note that we've loaded this input file.
2223   F.InputFilesLoaded[ID-1] = IF;
2224   return IF;
2225 }
2226 
2227 const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) {
2228   ModuleFile &M = ModuleMgr.getPrimaryModule();
2229   std::string Filename = filenameStrRef;
2230   MaybeAddSystemRootToFilename(M, Filename);
2231   const FileEntry *File = FileMgr.getFile(Filename);
2232   if (File == nullptr && !M.OriginalDir.empty() && !CurrentDir.empty() &&
2233       M.OriginalDir != CurrentDir) {
2234     std::string resolved = resolveFileRelativeToOriginalDir(Filename,
2235                                                             M.OriginalDir,
2236                                                             CurrentDir);
2237     if (!resolved.empty())
2238       File = FileMgr.getFile(resolved);
2239   }
2240 
2241   return File;
2242 }
2243 
2244 /// \brief If we are loading a relocatable PCH file, and the filename is
2245 /// not an absolute path, add the system root to the beginning of the file
2246 /// name.
2247 void ASTReader::MaybeAddSystemRootToFilename(ModuleFile &M,
2248                                              std::string &Filename) {
2249   // If this is not a relocatable PCH file, there's nothing to do.
2250   if (!M.RelocatablePCH)
2251     return;
2252 
2253   if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2254     return;
2255 
2256   if (isysroot.empty()) {
2257     // If no system root was given, default to '/'
2258     Filename.insert(Filename.begin(), '/');
2259     return;
2260   }
2261 
2262   unsigned Length = isysroot.size();
2263   if (isysroot[Length - 1] != '/')
2264     Filename.insert(Filename.begin(), '/');
2265 
2266   Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
2267 }
2268 
2269 ASTReader::ASTReadResult
2270 ASTReader::ReadControlBlock(ModuleFile &F,
2271                             SmallVectorImpl<ImportedModule> &Loaded,
2272                             const ModuleFile *ImportedBy,
2273                             unsigned ClientLoadCapabilities) {
2274   BitstreamCursor &Stream = F.Stream;
2275 
2276   if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2277     Error("malformed block record in AST file");
2278     return Failure;
2279   }
2280 
2281   // Should we allow the configuration of the module file to differ from the
2282   // configuration of the current translation unit in a compatible way?
2283   //
2284   // FIXME: Allow this for files explicitly specified with -include-pch too.
2285   bool AllowCompatibleConfigurationMismatch = F.Kind == MK_ExplicitModule;
2286 
2287   // Read all of the records and blocks in the control block.
2288   RecordData Record;
2289   unsigned NumInputs = 0;
2290   unsigned NumUserInputs = 0;
2291   while (1) {
2292     llvm::BitstreamEntry Entry = Stream.advance();
2293 
2294     switch (Entry.Kind) {
2295     case llvm::BitstreamEntry::Error:
2296       Error("malformed block record in AST file");
2297       return Failure;
2298     case llvm::BitstreamEntry::EndBlock: {
2299       // Validate input files.
2300       const HeaderSearchOptions &HSOpts =
2301           PP.getHeaderSearchInfo().getHeaderSearchOpts();
2302 
2303       // All user input files reside at the index range [0, NumUserInputs), and
2304       // system input files reside at [NumUserInputs, NumInputs).
2305       if (!DisableValidation) {
2306         bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2307 
2308         // If we are reading a module, we will create a verification timestamp,
2309         // so we verify all input files.  Otherwise, verify only user input
2310         // files.
2311 
2312         unsigned N = NumUserInputs;
2313         if (ValidateSystemInputs ||
2314             (HSOpts.ModulesValidateOncePerBuildSession &&
2315              F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2316              F.Kind == MK_ImplicitModule))
2317           N = NumInputs;
2318 
2319         for (unsigned I = 0; I < N; ++I) {
2320           InputFile IF = getInputFile(F, I+1, Complain);
2321           if (!IF.getFile() || IF.isOutOfDate())
2322             return OutOfDate;
2323         }
2324       }
2325 
2326       if (Listener)
2327         Listener->visitModuleFile(F.FileName);
2328 
2329       if (Listener && Listener->needsInputFileVisitation()) {
2330         unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2331                                                                 : NumUserInputs;
2332         for (unsigned I = 0; I < N; ++I) {
2333           bool IsSystem = I >= NumUserInputs;
2334           InputFileInfo FI = readInputFileInfo(F, I+1);
2335           Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden);
2336         }
2337       }
2338 
2339       return Success;
2340     }
2341 
2342     case llvm::BitstreamEntry::SubBlock:
2343       switch (Entry.ID) {
2344       case INPUT_FILES_BLOCK_ID:
2345         F.InputFilesCursor = Stream;
2346         if (Stream.SkipBlock() || // Skip with the main cursor
2347             // Read the abbreviations
2348             ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2349           Error("malformed block record in AST file");
2350           return Failure;
2351         }
2352         continue;
2353 
2354       default:
2355         if (Stream.SkipBlock()) {
2356           Error("malformed block record in AST file");
2357           return Failure;
2358         }
2359         continue;
2360       }
2361 
2362     case llvm::BitstreamEntry::Record:
2363       // The interesting case.
2364       break;
2365     }
2366 
2367     // Read and process a record.
2368     Record.clear();
2369     StringRef Blob;
2370     switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2371     case METADATA: {
2372       if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2373         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2374           Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2375                                         : diag::err_pch_version_too_new);
2376         return VersionMismatch;
2377       }
2378 
2379       bool hasErrors = Record[5];
2380       if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2381         Diag(diag::err_pch_with_compiler_errors);
2382         return HadErrors;
2383       }
2384 
2385       F.RelocatablePCH = Record[4];
2386 
2387       const std::string &CurBranch = getClangFullRepositoryVersion();
2388       StringRef ASTBranch = Blob;
2389       if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2390         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2391           Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2392         return VersionMismatch;
2393       }
2394       break;
2395     }
2396 
2397     case SIGNATURE:
2398       assert((!F.Signature || F.Signature == Record[0]) && "signature changed");
2399       F.Signature = Record[0];
2400       break;
2401 
2402     case IMPORTS: {
2403       // Load each of the imported PCH files.
2404       unsigned Idx = 0, N = Record.size();
2405       while (Idx < N) {
2406         // Read information about the AST file.
2407         ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2408         // The import location will be the local one for now; we will adjust
2409         // all import locations of module imports after the global source
2410         // location info are setup.
2411         SourceLocation ImportLoc =
2412             SourceLocation::getFromRawEncoding(Record[Idx++]);
2413         off_t StoredSize = (off_t)Record[Idx++];
2414         time_t StoredModTime = (time_t)Record[Idx++];
2415         ASTFileSignature StoredSignature = Record[Idx++];
2416         unsigned Length = Record[Idx++];
2417         SmallString<128> ImportedFile(Record.begin() + Idx,
2418                                       Record.begin() + Idx + Length);
2419         Idx += Length;
2420 
2421         // Load the AST file.
2422         switch(ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F, Loaded,
2423                            StoredSize, StoredModTime, StoredSignature,
2424                            ClientLoadCapabilities)) {
2425         case Failure: return Failure;
2426           // If we have to ignore the dependency, we'll have to ignore this too.
2427         case Missing:
2428         case OutOfDate: return OutOfDate;
2429         case VersionMismatch: return VersionMismatch;
2430         case ConfigurationMismatch: return ConfigurationMismatch;
2431         case HadErrors: return HadErrors;
2432         case Success: break;
2433         }
2434       }
2435       break;
2436     }
2437 
2438     case LANGUAGE_OPTIONS: {
2439       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2440       // FIXME: The &F == *ModuleMgr.begin() check is wrong for modules.
2441       if (Listener && &F == *ModuleMgr.begin() &&
2442           ParseLanguageOptions(Record, Complain, *Listener,
2443                                AllowCompatibleConfigurationMismatch) &&
2444           !DisableValidation && !AllowConfigurationMismatch)
2445         return ConfigurationMismatch;
2446       break;
2447     }
2448 
2449     case TARGET_OPTIONS: {
2450       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2451       if (Listener && &F == *ModuleMgr.begin() &&
2452           ParseTargetOptions(Record, Complain, *Listener) &&
2453           !DisableValidation && !AllowConfigurationMismatch)
2454         return ConfigurationMismatch;
2455       break;
2456     }
2457 
2458     case DIAGNOSTIC_OPTIONS: {
2459       bool Complain = (ClientLoadCapabilities & ARR_OutOfDate)==0;
2460       if (Listener && &F == *ModuleMgr.begin() &&
2461           !AllowCompatibleConfigurationMismatch &&
2462           ParseDiagnosticOptions(Record, Complain, *Listener) &&
2463           !DisableValidation)
2464         return OutOfDate;
2465       break;
2466     }
2467 
2468     case FILE_SYSTEM_OPTIONS: {
2469       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2470       if (Listener && &F == *ModuleMgr.begin() &&
2471           !AllowCompatibleConfigurationMismatch &&
2472           ParseFileSystemOptions(Record, Complain, *Listener) &&
2473           !DisableValidation && !AllowConfigurationMismatch)
2474         return ConfigurationMismatch;
2475       break;
2476     }
2477 
2478     case HEADER_SEARCH_OPTIONS: {
2479       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2480       if (Listener && &F == *ModuleMgr.begin() &&
2481           !AllowCompatibleConfigurationMismatch &&
2482           ParseHeaderSearchOptions(Record, Complain, *Listener) &&
2483           !DisableValidation && !AllowConfigurationMismatch)
2484         return ConfigurationMismatch;
2485       break;
2486     }
2487 
2488     case PREPROCESSOR_OPTIONS: {
2489       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
2490       if (Listener && &F == *ModuleMgr.begin() &&
2491           !AllowCompatibleConfigurationMismatch &&
2492           ParsePreprocessorOptions(Record, Complain, *Listener,
2493                                    SuggestedPredefines) &&
2494           !DisableValidation && !AllowConfigurationMismatch)
2495         return ConfigurationMismatch;
2496       break;
2497     }
2498 
2499     case ORIGINAL_FILE:
2500       F.OriginalSourceFileID = FileID::get(Record[0]);
2501       F.ActualOriginalSourceFileName = Blob;
2502       F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2503       MaybeAddSystemRootToFilename(F, F.OriginalSourceFileName);
2504       break;
2505 
2506     case ORIGINAL_FILE_ID:
2507       F.OriginalSourceFileID = FileID::get(Record[0]);
2508       break;
2509 
2510     case ORIGINAL_PCH_DIR:
2511       F.OriginalDir = Blob;
2512       break;
2513 
2514     case MODULE_NAME:
2515       F.ModuleName = Blob;
2516       if (Listener)
2517         Listener->ReadModuleName(F.ModuleName);
2518       break;
2519 
2520     case MODULE_MAP_FILE:
2521       if (ASTReadResult Result =
2522               ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2523         return Result;
2524       break;
2525 
2526     case INPUT_FILE_OFFSETS:
2527       NumInputs = Record[0];
2528       NumUserInputs = Record[1];
2529       F.InputFileOffsets = (const uint32_t *)Blob.data();
2530       F.InputFilesLoaded.resize(NumInputs);
2531       break;
2532     }
2533   }
2534 }
2535 
2536 ASTReader::ASTReadResult
2537 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2538   BitstreamCursor &Stream = F.Stream;
2539 
2540   if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2541     Error("malformed block record in AST file");
2542     return Failure;
2543   }
2544 
2545   // Read all of the records and blocks for the AST file.
2546   RecordData Record;
2547   while (1) {
2548     llvm::BitstreamEntry Entry = Stream.advance();
2549 
2550     switch (Entry.Kind) {
2551     case llvm::BitstreamEntry::Error:
2552       Error("error at end of module block in AST file");
2553       return Failure;
2554     case llvm::BitstreamEntry::EndBlock: {
2555       // Outside of C++, we do not store a lookup map for the translation unit.
2556       // Instead, mark it as needing a lookup map to be built if this module
2557       // contains any declarations lexically within it (which it always does!).
2558       // This usually has no cost, since we very rarely need the lookup map for
2559       // the translation unit outside C++.
2560       DeclContext *DC = Context.getTranslationUnitDecl();
2561       if (DC->hasExternalLexicalStorage() &&
2562           !getContext().getLangOpts().CPlusPlus)
2563         DC->setMustBuildLookupTable();
2564 
2565       return Success;
2566     }
2567     case llvm::BitstreamEntry::SubBlock:
2568       switch (Entry.ID) {
2569       case DECLTYPES_BLOCK_ID:
2570         // We lazily load the decls block, but we want to set up the
2571         // DeclsCursor cursor to point into it.  Clone our current bitcode
2572         // cursor to it, enter the block and read the abbrevs in that block.
2573         // With the main cursor, we just skip over it.
2574         F.DeclsCursor = Stream;
2575         if (Stream.SkipBlock() ||  // Skip with the main cursor.
2576             // Read the abbrevs.
2577             ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2578           Error("malformed block record in AST file");
2579           return Failure;
2580         }
2581         break;
2582 
2583       case PREPROCESSOR_BLOCK_ID:
2584         F.MacroCursor = Stream;
2585         if (!PP.getExternalSource())
2586           PP.setExternalSource(this);
2587 
2588         if (Stream.SkipBlock() ||
2589             ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2590           Error("malformed block record in AST file");
2591           return Failure;
2592         }
2593         F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2594         break;
2595 
2596       case PREPROCESSOR_DETAIL_BLOCK_ID:
2597         F.PreprocessorDetailCursor = Stream;
2598         if (Stream.SkipBlock() ||
2599             ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2600                              PREPROCESSOR_DETAIL_BLOCK_ID)) {
2601               Error("malformed preprocessor detail record in AST file");
2602               return Failure;
2603             }
2604         F.PreprocessorDetailStartOffset
2605         = F.PreprocessorDetailCursor.GetCurrentBitNo();
2606 
2607         if (!PP.getPreprocessingRecord())
2608           PP.createPreprocessingRecord();
2609         if (!PP.getPreprocessingRecord()->getExternalSource())
2610           PP.getPreprocessingRecord()->SetExternalSource(*this);
2611         break;
2612 
2613       case SOURCE_MANAGER_BLOCK_ID:
2614         if (ReadSourceManagerBlock(F))
2615           return Failure;
2616         break;
2617 
2618       case SUBMODULE_BLOCK_ID:
2619         if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities))
2620           return Result;
2621         break;
2622 
2623       case COMMENTS_BLOCK_ID: {
2624         BitstreamCursor C = Stream;
2625         if (Stream.SkipBlock() ||
2626             ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2627           Error("malformed comments block in AST file");
2628           return Failure;
2629         }
2630         CommentsCursors.push_back(std::make_pair(C, &F));
2631         break;
2632       }
2633 
2634       default:
2635         if (Stream.SkipBlock()) {
2636           Error("malformed block record in AST file");
2637           return Failure;
2638         }
2639         break;
2640       }
2641       continue;
2642 
2643     case llvm::BitstreamEntry::Record:
2644       // The interesting case.
2645       break;
2646     }
2647 
2648     // Read and process a record.
2649     Record.clear();
2650     StringRef Blob;
2651     switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2652     default:  // Default behavior: ignore.
2653       break;
2654 
2655     case TYPE_OFFSET: {
2656       if (F.LocalNumTypes != 0) {
2657         Error("duplicate TYPE_OFFSET record in AST file");
2658         return Failure;
2659       }
2660       F.TypeOffsets = (const uint32_t *)Blob.data();
2661       F.LocalNumTypes = Record[0];
2662       unsigned LocalBaseTypeIndex = Record[1];
2663       F.BaseTypeIndex = getTotalNumTypes();
2664 
2665       if (F.LocalNumTypes > 0) {
2666         // Introduce the global -> local mapping for types within this module.
2667         GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2668 
2669         // Introduce the local -> global mapping for types within this module.
2670         F.TypeRemap.insertOrReplace(
2671           std::make_pair(LocalBaseTypeIndex,
2672                          F.BaseTypeIndex - LocalBaseTypeIndex));
2673 
2674         TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2675       }
2676       break;
2677     }
2678 
2679     case DECL_OFFSET: {
2680       if (F.LocalNumDecls != 0) {
2681         Error("duplicate DECL_OFFSET record in AST file");
2682         return Failure;
2683       }
2684       F.DeclOffsets = (const DeclOffset *)Blob.data();
2685       F.LocalNumDecls = Record[0];
2686       unsigned LocalBaseDeclID = Record[1];
2687       F.BaseDeclID = getTotalNumDecls();
2688 
2689       if (F.LocalNumDecls > 0) {
2690         // Introduce the global -> local mapping for declarations within this
2691         // module.
2692         GlobalDeclMap.insert(
2693           std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2694 
2695         // Introduce the local -> global mapping for declarations within this
2696         // module.
2697         F.DeclRemap.insertOrReplace(
2698           std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2699 
2700         // Introduce the global -> local mapping for declarations within this
2701         // module.
2702         F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2703 
2704         DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2705       }
2706       break;
2707     }
2708 
2709     case TU_UPDATE_LEXICAL: {
2710       DeclContext *TU = Context.getTranslationUnitDecl();
2711       DeclContextInfo &Info = F.DeclContextInfos[TU];
2712       Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(Blob.data());
2713       Info.NumLexicalDecls
2714         = static_cast<unsigned int>(Blob.size() / sizeof(KindDeclIDPair));
2715       TU->setHasExternalLexicalStorage(true);
2716       break;
2717     }
2718 
2719     case UPDATE_VISIBLE: {
2720       unsigned Idx = 0;
2721       serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2722       ASTDeclContextNameLookupTable *Table =
2723           ASTDeclContextNameLookupTable::Create(
2724               (const unsigned char *)Blob.data() + Record[Idx++],
2725               (const unsigned char *)Blob.data() + sizeof(uint32_t),
2726               (const unsigned char *)Blob.data(),
2727               ASTDeclContextNameLookupTrait(*this, F));
2728       if (Decl *D = GetExistingDecl(ID)) {
2729         auto *DC = cast<DeclContext>(D);
2730         DC->getPrimaryContext()->setHasExternalVisibleStorage(true);
2731         auto *&LookupTable = F.DeclContextInfos[DC].NameLookupTableData;
2732         delete LookupTable;
2733         LookupTable = Table;
2734       } else
2735         PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F));
2736       break;
2737     }
2738 
2739     case IDENTIFIER_TABLE:
2740       F.IdentifierTableData = Blob.data();
2741       if (Record[0]) {
2742         F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2743             (const unsigned char *)F.IdentifierTableData + Record[0],
2744             (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2745             (const unsigned char *)F.IdentifierTableData,
2746             ASTIdentifierLookupTrait(*this, F));
2747 
2748         PP.getIdentifierTable().setExternalIdentifierLookup(this);
2749       }
2750       break;
2751 
2752     case IDENTIFIER_OFFSET: {
2753       if (F.LocalNumIdentifiers != 0) {
2754         Error("duplicate IDENTIFIER_OFFSET record in AST file");
2755         return Failure;
2756       }
2757       F.IdentifierOffsets = (const uint32_t *)Blob.data();
2758       F.LocalNumIdentifiers = Record[0];
2759       unsigned LocalBaseIdentifierID = Record[1];
2760       F.BaseIdentifierID = getTotalNumIdentifiers();
2761 
2762       if (F.LocalNumIdentifiers > 0) {
2763         // Introduce the global -> local mapping for identifiers within this
2764         // module.
2765         GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2766                                                   &F));
2767 
2768         // Introduce the local -> global mapping for identifiers within this
2769         // module.
2770         F.IdentifierRemap.insertOrReplace(
2771           std::make_pair(LocalBaseIdentifierID,
2772                          F.BaseIdentifierID - LocalBaseIdentifierID));
2773 
2774         IdentifiersLoaded.resize(IdentifiersLoaded.size()
2775                                  + F.LocalNumIdentifiers);
2776       }
2777       break;
2778     }
2779 
2780     case EAGERLY_DESERIALIZED_DECLS:
2781       for (unsigned I = 0, N = Record.size(); I != N; ++I)
2782         EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2783       break;
2784 
2785     case SPECIAL_TYPES:
2786       if (SpecialTypes.empty()) {
2787         for (unsigned I = 0, N = Record.size(); I != N; ++I)
2788           SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2789         break;
2790       }
2791 
2792       if (SpecialTypes.size() != Record.size()) {
2793         Error("invalid special-types record");
2794         return Failure;
2795       }
2796 
2797       for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2798         serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2799         if (!SpecialTypes[I])
2800           SpecialTypes[I] = ID;
2801         // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2802         // merge step?
2803       }
2804       break;
2805 
2806     case STATISTICS:
2807       TotalNumStatements += Record[0];
2808       TotalNumMacros += Record[1];
2809       TotalLexicalDeclContexts += Record[2];
2810       TotalVisibleDeclContexts += Record[3];
2811       break;
2812 
2813     case UNUSED_FILESCOPED_DECLS:
2814       for (unsigned I = 0, N = Record.size(); I != N; ++I)
2815         UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2816       break;
2817 
2818     case DELEGATING_CTORS:
2819       for (unsigned I = 0, N = Record.size(); I != N; ++I)
2820         DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2821       break;
2822 
2823     case WEAK_UNDECLARED_IDENTIFIERS:
2824       if (Record.size() % 4 != 0) {
2825         Error("invalid weak identifiers record");
2826         return Failure;
2827       }
2828 
2829       // FIXME: Ignore weak undeclared identifiers from non-original PCH
2830       // files. This isn't the way to do it :)
2831       WeakUndeclaredIdentifiers.clear();
2832 
2833       // Translate the weak, undeclared identifiers into global IDs.
2834       for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2835         WeakUndeclaredIdentifiers.push_back(
2836           getGlobalIdentifierID(F, Record[I++]));
2837         WeakUndeclaredIdentifiers.push_back(
2838           getGlobalIdentifierID(F, Record[I++]));
2839         WeakUndeclaredIdentifiers.push_back(
2840           ReadSourceLocation(F, Record, I).getRawEncoding());
2841         WeakUndeclaredIdentifiers.push_back(Record[I++]);
2842       }
2843       break;
2844 
2845     case LOCALLY_SCOPED_EXTERN_C_DECLS:
2846       for (unsigned I = 0, N = Record.size(); I != N; ++I)
2847         LocallyScopedExternCDecls.push_back(getGlobalDeclID(F, Record[I]));
2848       break;
2849 
2850     case SELECTOR_OFFSETS: {
2851       F.SelectorOffsets = (const uint32_t *)Blob.data();
2852       F.LocalNumSelectors = Record[0];
2853       unsigned LocalBaseSelectorID = Record[1];
2854       F.BaseSelectorID = getTotalNumSelectors();
2855 
2856       if (F.LocalNumSelectors > 0) {
2857         // Introduce the global -> local mapping for selectors within this
2858         // module.
2859         GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2860 
2861         // Introduce the local -> global mapping for selectors within this
2862         // module.
2863         F.SelectorRemap.insertOrReplace(
2864           std::make_pair(LocalBaseSelectorID,
2865                          F.BaseSelectorID - LocalBaseSelectorID));
2866 
2867         SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2868       }
2869       break;
2870     }
2871 
2872     case METHOD_POOL:
2873       F.SelectorLookupTableData = (const unsigned char *)Blob.data();
2874       if (Record[0])
2875         F.SelectorLookupTable
2876           = ASTSelectorLookupTable::Create(
2877                         F.SelectorLookupTableData + Record[0],
2878                         F.SelectorLookupTableData,
2879                         ASTSelectorLookupTrait(*this, F));
2880       TotalNumMethodPoolEntries += Record[1];
2881       break;
2882 
2883     case REFERENCED_SELECTOR_POOL:
2884       if (!Record.empty()) {
2885         for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2886           ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2887                                                                 Record[Idx++]));
2888           ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2889                                               getRawEncoding());
2890         }
2891       }
2892       break;
2893 
2894     case PP_COUNTER_VALUE:
2895       if (!Record.empty() && Listener)
2896         Listener->ReadCounter(F, Record[0]);
2897       break;
2898 
2899     case FILE_SORTED_DECLS:
2900       F.FileSortedDecls = (const DeclID *)Blob.data();
2901       F.NumFileSortedDecls = Record[0];
2902       break;
2903 
2904     case SOURCE_LOCATION_OFFSETS: {
2905       F.SLocEntryOffsets = (const uint32_t *)Blob.data();
2906       F.LocalNumSLocEntries = Record[0];
2907       unsigned SLocSpaceSize = Record[1];
2908       std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2909           SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
2910                                               SLocSpaceSize);
2911       // Make our entry in the range map. BaseID is negative and growing, so
2912       // we invert it. Because we invert it, though, we need the other end of
2913       // the range.
2914       unsigned RangeStart =
2915           unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2916       GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2917       F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2918 
2919       // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2920       assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2921       GlobalSLocOffsetMap.insert(
2922           std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2923                            - SLocSpaceSize,&F));
2924 
2925       // Initialize the remapping table.
2926       // Invalid stays invalid.
2927       F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
2928       // This module. Base was 2 when being compiled.
2929       F.SLocRemap.insertOrReplace(std::make_pair(2U,
2930                                   static_cast<int>(F.SLocEntryBaseOffset - 2)));
2931 
2932       TotalNumSLocEntries += F.LocalNumSLocEntries;
2933       break;
2934     }
2935 
2936     case MODULE_OFFSET_MAP: {
2937       // Additional remapping information.
2938       const unsigned char *Data = (const unsigned char*)Blob.data();
2939       const unsigned char *DataEnd = Data + Blob.size();
2940 
2941       // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
2942       if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
2943         F.SLocRemap.insert(std::make_pair(0U, 0));
2944         F.SLocRemap.insert(std::make_pair(2U, 1));
2945       }
2946 
2947       // Continuous range maps we may be updating in our module.
2948       typedef ContinuousRangeMap<uint32_t, int, 2>::Builder
2949           RemapBuilder;
2950       RemapBuilder SLocRemap(F.SLocRemap);
2951       RemapBuilder IdentifierRemap(F.IdentifierRemap);
2952       RemapBuilder MacroRemap(F.MacroRemap);
2953       RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2954       RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
2955       RemapBuilder SelectorRemap(F.SelectorRemap);
2956       RemapBuilder DeclRemap(F.DeclRemap);
2957       RemapBuilder TypeRemap(F.TypeRemap);
2958 
2959       while(Data < DataEnd) {
2960         using namespace llvm::support;
2961         uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
2962         StringRef Name = StringRef((const char*)Data, Len);
2963         Data += Len;
2964         ModuleFile *OM = ModuleMgr.lookup(Name);
2965         if (!OM) {
2966           Error("SourceLocation remap refers to unknown module");
2967           return Failure;
2968         }
2969 
2970         uint32_t SLocOffset =
2971             endian::readNext<uint32_t, little, unaligned>(Data);
2972         uint32_t IdentifierIDOffset =
2973             endian::readNext<uint32_t, little, unaligned>(Data);
2974         uint32_t MacroIDOffset =
2975             endian::readNext<uint32_t, little, unaligned>(Data);
2976         uint32_t PreprocessedEntityIDOffset =
2977             endian::readNext<uint32_t, little, unaligned>(Data);
2978         uint32_t SubmoduleIDOffset =
2979             endian::readNext<uint32_t, little, unaligned>(Data);
2980         uint32_t SelectorIDOffset =
2981             endian::readNext<uint32_t, little, unaligned>(Data);
2982         uint32_t DeclIDOffset =
2983             endian::readNext<uint32_t, little, unaligned>(Data);
2984         uint32_t TypeIndexOffset =
2985             endian::readNext<uint32_t, little, unaligned>(Data);
2986 
2987         uint32_t None = std::numeric_limits<uint32_t>::max();
2988 
2989         auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
2990                              RemapBuilder &Remap) {
2991           if (Offset != None)
2992             Remap.insert(std::make_pair(Offset,
2993                                         static_cast<int>(BaseOffset - Offset)));
2994         };
2995         mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
2996         mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
2997         mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
2998         mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
2999                   PreprocessedEntityRemap);
3000         mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3001         mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3002         mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3003         mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3004 
3005         // Global -> local mappings.
3006         F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3007       }
3008       break;
3009     }
3010 
3011     case SOURCE_MANAGER_LINE_TABLE:
3012       if (ParseLineTable(F, Record))
3013         return Failure;
3014       break;
3015 
3016     case SOURCE_LOCATION_PRELOADS: {
3017       // Need to transform from the local view (1-based IDs) to the global view,
3018       // which is based off F.SLocEntryBaseID.
3019       if (!F.PreloadSLocEntries.empty()) {
3020         Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3021         return Failure;
3022       }
3023 
3024       F.PreloadSLocEntries.swap(Record);
3025       break;
3026     }
3027 
3028     case EXT_VECTOR_DECLS:
3029       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3030         ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3031       break;
3032 
3033     case VTABLE_USES:
3034       if (Record.size() % 3 != 0) {
3035         Error("Invalid VTABLE_USES record");
3036         return Failure;
3037       }
3038 
3039       // Later tables overwrite earlier ones.
3040       // FIXME: Modules will have some trouble with this. This is clearly not
3041       // the right way to do this.
3042       VTableUses.clear();
3043 
3044       for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3045         VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3046         VTableUses.push_back(
3047           ReadSourceLocation(F, Record, Idx).getRawEncoding());
3048         VTableUses.push_back(Record[Idx++]);
3049       }
3050       break;
3051 
3052     case DYNAMIC_CLASSES:
3053       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3054         DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
3055       break;
3056 
3057     case PENDING_IMPLICIT_INSTANTIATIONS:
3058       if (PendingInstantiations.size() % 2 != 0) {
3059         Error("Invalid existing PendingInstantiations");
3060         return Failure;
3061       }
3062 
3063       if (Record.size() % 2 != 0) {
3064         Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3065         return Failure;
3066       }
3067 
3068       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3069         PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3070         PendingInstantiations.push_back(
3071           ReadSourceLocation(F, Record, I).getRawEncoding());
3072       }
3073       break;
3074 
3075     case SEMA_DECL_REFS:
3076       if (Record.size() != 2) {
3077         Error("Invalid SEMA_DECL_REFS block");
3078         return Failure;
3079       }
3080       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3081         SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3082       break;
3083 
3084     case PPD_ENTITIES_OFFSETS: {
3085       F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3086       assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3087       F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3088 
3089       unsigned LocalBasePreprocessedEntityID = Record[0];
3090 
3091       unsigned StartingID;
3092       if (!PP.getPreprocessingRecord())
3093         PP.createPreprocessingRecord();
3094       if (!PP.getPreprocessingRecord()->getExternalSource())
3095         PP.getPreprocessingRecord()->SetExternalSource(*this);
3096       StartingID
3097         = PP.getPreprocessingRecord()
3098             ->allocateLoadedEntities(F.NumPreprocessedEntities);
3099       F.BasePreprocessedEntityID = StartingID;
3100 
3101       if (F.NumPreprocessedEntities > 0) {
3102         // Introduce the global -> local mapping for preprocessed entities in
3103         // this module.
3104         GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3105 
3106         // Introduce the local -> global mapping for preprocessed entities in
3107         // this module.
3108         F.PreprocessedEntityRemap.insertOrReplace(
3109           std::make_pair(LocalBasePreprocessedEntityID,
3110             F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3111       }
3112 
3113       break;
3114     }
3115 
3116     case DECL_UPDATE_OFFSETS: {
3117       if (Record.size() % 2 != 0) {
3118         Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3119         return Failure;
3120       }
3121       for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3122         GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3123         DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3124 
3125         // If we've already loaded the decl, perform the updates when we finish
3126         // loading this block.
3127         if (Decl *D = GetExistingDecl(ID))
3128           PendingUpdateRecords.push_back(std::make_pair(ID, D));
3129       }
3130       break;
3131     }
3132 
3133     case DECL_REPLACEMENTS: {
3134       if (Record.size() % 3 != 0) {
3135         Error("invalid DECL_REPLACEMENTS block in AST file");
3136         return Failure;
3137       }
3138       for (unsigned I = 0, N = Record.size(); I != N; I += 3)
3139         ReplacedDecls[getGlobalDeclID(F, Record[I])]
3140           = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]);
3141       break;
3142     }
3143 
3144     case OBJC_CATEGORIES_MAP: {
3145       if (F.LocalNumObjCCategoriesInMap != 0) {
3146         Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3147         return Failure;
3148       }
3149 
3150       F.LocalNumObjCCategoriesInMap = Record[0];
3151       F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3152       break;
3153     }
3154 
3155     case OBJC_CATEGORIES:
3156       F.ObjCCategories.swap(Record);
3157       break;
3158 
3159     case CXX_BASE_SPECIFIER_OFFSETS: {
3160       if (F.LocalNumCXXBaseSpecifiers != 0) {
3161         Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
3162         return Failure;
3163       }
3164 
3165       F.LocalNumCXXBaseSpecifiers = Record[0];
3166       F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data();
3167       NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
3168       break;
3169     }
3170 
3171     case DIAG_PRAGMA_MAPPINGS:
3172       if (F.PragmaDiagMappings.empty())
3173         F.PragmaDiagMappings.swap(Record);
3174       else
3175         F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
3176                                     Record.begin(), Record.end());
3177       break;
3178 
3179     case CUDA_SPECIAL_DECL_REFS:
3180       // Later tables overwrite earlier ones.
3181       // FIXME: Modules will have trouble with this.
3182       CUDASpecialDeclRefs.clear();
3183       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3184         CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3185       break;
3186 
3187     case HEADER_SEARCH_TABLE: {
3188       F.HeaderFileInfoTableData = Blob.data();
3189       F.LocalNumHeaderFileInfos = Record[1];
3190       if (Record[0]) {
3191         F.HeaderFileInfoTable
3192           = HeaderFileInfoLookupTable::Create(
3193                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3194                    (const unsigned char *)F.HeaderFileInfoTableData,
3195                    HeaderFileInfoTrait(*this, F,
3196                                        &PP.getHeaderSearchInfo(),
3197                                        Blob.data() + Record[2]));
3198 
3199         PP.getHeaderSearchInfo().SetExternalSource(this);
3200         if (!PP.getHeaderSearchInfo().getExternalLookup())
3201           PP.getHeaderSearchInfo().SetExternalLookup(this);
3202       }
3203       break;
3204     }
3205 
3206     case FP_PRAGMA_OPTIONS:
3207       // Later tables overwrite earlier ones.
3208       FPPragmaOptions.swap(Record);
3209       break;
3210 
3211     case OPENCL_EXTENSIONS:
3212       // Later tables overwrite earlier ones.
3213       OpenCLExtensions.swap(Record);
3214       break;
3215 
3216     case TENTATIVE_DEFINITIONS:
3217       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3218         TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3219       break;
3220 
3221     case KNOWN_NAMESPACES:
3222       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3223         KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3224       break;
3225 
3226     case UNDEFINED_BUT_USED:
3227       if (UndefinedButUsed.size() % 2 != 0) {
3228         Error("Invalid existing UndefinedButUsed");
3229         return Failure;
3230       }
3231 
3232       if (Record.size() % 2 != 0) {
3233         Error("invalid undefined-but-used record");
3234         return Failure;
3235       }
3236       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3237         UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3238         UndefinedButUsed.push_back(
3239             ReadSourceLocation(F, Record, I).getRawEncoding());
3240       }
3241       break;
3242 
3243     case IMPORTED_MODULES: {
3244       if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) {
3245         // If we aren't loading a module (which has its own exports), make
3246         // all of the imported modules visible.
3247         // FIXME: Deal with macros-only imports.
3248         for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3249           unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3250           SourceLocation Loc = ReadSourceLocation(F, Record, I);
3251           if (GlobalID)
3252             ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3253         }
3254       }
3255       break;
3256     }
3257 
3258     case LOCAL_REDECLARATIONS: {
3259       F.RedeclarationChains.swap(Record);
3260       break;
3261     }
3262 
3263     case LOCAL_REDECLARATIONS_MAP: {
3264       if (F.LocalNumRedeclarationsInMap != 0) {
3265         Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file");
3266         return Failure;
3267       }
3268 
3269       F.LocalNumRedeclarationsInMap = Record[0];
3270       F.RedeclarationsMap = (const LocalRedeclarationsInfo *)Blob.data();
3271       break;
3272     }
3273 
3274     case MERGED_DECLARATIONS: {
3275       for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) {
3276         GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]);
3277         SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID];
3278         for (unsigned N = Record[Idx++]; N > 0; --N)
3279           Decls.push_back(getGlobalDeclID(F, Record[Idx++]));
3280       }
3281       break;
3282     }
3283 
3284     case MACRO_OFFSET: {
3285       if (F.LocalNumMacros != 0) {
3286         Error("duplicate MACRO_OFFSET record in AST file");
3287         return Failure;
3288       }
3289       F.MacroOffsets = (const uint32_t *)Blob.data();
3290       F.LocalNumMacros = Record[0];
3291       unsigned LocalBaseMacroID = Record[1];
3292       F.BaseMacroID = getTotalNumMacros();
3293 
3294       if (F.LocalNumMacros > 0) {
3295         // Introduce the global -> local mapping for macros within this module.
3296         GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3297 
3298         // Introduce the local -> global mapping for macros within this module.
3299         F.MacroRemap.insertOrReplace(
3300           std::make_pair(LocalBaseMacroID,
3301                          F.BaseMacroID - LocalBaseMacroID));
3302 
3303         MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3304       }
3305       break;
3306     }
3307 
3308     case MACRO_TABLE: {
3309       // FIXME: Not used yet.
3310       break;
3311     }
3312 
3313     case LATE_PARSED_TEMPLATE: {
3314       LateParsedTemplates.append(Record.begin(), Record.end());
3315       break;
3316     }
3317 
3318     case OPTIMIZE_PRAGMA_OPTIONS:
3319       if (Record.size() != 1) {
3320         Error("invalid pragma optimize record");
3321         return Failure;
3322       }
3323       OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3324       break;
3325 
3326     case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3327       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3328         UnusedLocalTypedefNameCandidates.push_back(
3329             getGlobalDeclID(F, Record[I]));
3330       break;
3331     }
3332   }
3333 }
3334 
3335 ASTReader::ASTReadResult
3336 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3337                                   const ModuleFile *ImportedBy,
3338                                   unsigned ClientLoadCapabilities) {
3339   unsigned Idx = 0;
3340   F.ModuleMapPath = ReadString(Record, Idx);
3341 
3342   if (F.Kind == MK_ExplicitModule) {
3343     // For an explicitly-loaded module, we don't care whether the original
3344     // module map file exists or matches.
3345     return Success;
3346   }
3347 
3348   // Try to resolve ModuleName in the current header search context and
3349   // verify that it is found in the same module map file as we saved. If the
3350   // top-level AST file is a main file, skip this check because there is no
3351   // usable header search context.
3352   assert(!F.ModuleName.empty() &&
3353          "MODULE_NAME should come before MODULE_MAP_FILE");
3354   if (F.Kind == MK_ImplicitModule &&
3355       (*ModuleMgr.begin())->Kind != MK_MainFile) {
3356     // An implicitly-loaded module file should have its module listed in some
3357     // module map file that we've already loaded.
3358     Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3359     auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3360     const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3361     if (!ModMap) {
3362       assert(ImportedBy && "top-level import should be verified");
3363       if ((ClientLoadCapabilities & ARR_Missing) == 0)
3364         Diag(diag::err_imported_module_not_found) << F.ModuleName << F.FileName
3365                                                   << ImportedBy->FileName
3366                                                   << F.ModuleMapPath;
3367       return Missing;
3368     }
3369 
3370     assert(M->Name == F.ModuleName && "found module with different name");
3371 
3372     // Check the primary module map file.
3373     const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3374     if (StoredModMap == nullptr || StoredModMap != ModMap) {
3375       assert(ModMap && "found module is missing module map file");
3376       assert(ImportedBy && "top-level import should be verified");
3377       if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3378         Diag(diag::err_imported_module_modmap_changed)
3379           << F.ModuleName << ImportedBy->FileName
3380           << ModMap->getName() << F.ModuleMapPath;
3381       return OutOfDate;
3382     }
3383 
3384     llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3385     for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3386       // FIXME: we should use input files rather than storing names.
3387       std::string Filename = ReadString(Record, Idx);
3388       const FileEntry *F =
3389           FileMgr.getFile(Filename, false, false);
3390       if (F == nullptr) {
3391         if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3392           Error("could not find file '" + Filename +"' referenced by AST file");
3393         return OutOfDate;
3394       }
3395       AdditionalStoredMaps.insert(F);
3396     }
3397 
3398     // Check any additional module map files (e.g. module.private.modulemap)
3399     // that are not in the pcm.
3400     if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3401       for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3402         // Remove files that match
3403         // Note: SmallPtrSet::erase is really remove
3404         if (!AdditionalStoredMaps.erase(ModMap)) {
3405           if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3406             Diag(diag::err_module_different_modmap)
3407               << F.ModuleName << /*new*/0 << ModMap->getName();
3408           return OutOfDate;
3409         }
3410       }
3411     }
3412 
3413     // Check any additional module map files that are in the pcm, but not
3414     // found in header search. Cases that match are already removed.
3415     for (const FileEntry *ModMap : AdditionalStoredMaps) {
3416       if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3417         Diag(diag::err_module_different_modmap)
3418           << F.ModuleName << /*not new*/1 << ModMap->getName();
3419       return OutOfDate;
3420     }
3421   }
3422 
3423   if (Listener)
3424     Listener->ReadModuleMapFile(F.ModuleMapPath);
3425   return Success;
3426 }
3427 
3428 
3429 /// \brief Move the given method to the back of the global list of methods.
3430 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3431   // Find the entry for this selector in the method pool.
3432   Sema::GlobalMethodPool::iterator Known
3433     = S.MethodPool.find(Method->getSelector());
3434   if (Known == S.MethodPool.end())
3435     return;
3436 
3437   // Retrieve the appropriate method list.
3438   ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3439                                                     : Known->second.second;
3440   bool Found = false;
3441   for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3442     if (!Found) {
3443       if (List->Method == Method) {
3444         Found = true;
3445       } else {
3446         // Keep searching.
3447         continue;
3448       }
3449     }
3450 
3451     if (List->getNext())
3452       List->Method = List->getNext()->Method;
3453     else
3454       List->Method = Method;
3455   }
3456 }
3457 
3458 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner,
3459                                  bool FromFinalization) {
3460   // FIXME: Only do this if Owner->NameVisibility == AllVisible.
3461   for (Decl *D : Names.HiddenDecls) {
3462     bool wasHidden = D->Hidden;
3463     D->Hidden = false;
3464 
3465     if (wasHidden && SemaObj) {
3466       if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3467         moveMethodToBackOfGlobalList(*SemaObj, Method);
3468       }
3469     }
3470   }
3471 
3472   assert((FromFinalization || Owner->NameVisibility >= Module::MacrosVisible) &&
3473          "nothing to make visible?");
3474   for (const auto &Macro : Names.HiddenMacros) {
3475     if (FromFinalization)
3476       PP.appendMacroDirective(Macro.first,
3477                               Macro.second->import(PP, SourceLocation()));
3478     else
3479       installImportedMacro(Macro.first, Macro.second, Owner);
3480   }
3481 }
3482 
3483 void ASTReader::makeModuleVisible(Module *Mod,
3484                                   Module::NameVisibilityKind NameVisibility,
3485                                   SourceLocation ImportLoc,
3486                                   bool Complain) {
3487   llvm::SmallPtrSet<Module *, 4> Visited;
3488   SmallVector<Module *, 4> Stack;
3489   Stack.push_back(Mod);
3490   while (!Stack.empty()) {
3491     Mod = Stack.pop_back_val();
3492 
3493     if (NameVisibility <= Mod->NameVisibility) {
3494       // This module already has this level of visibility (or greater), so
3495       // there is nothing more to do.
3496       continue;
3497     }
3498 
3499     if (!Mod->isAvailable()) {
3500       // Modules that aren't available cannot be made visible.
3501       continue;
3502     }
3503 
3504     // Update the module's name visibility.
3505     if (NameVisibility >= Module::MacrosVisible &&
3506         Mod->NameVisibility < Module::MacrosVisible)
3507       Mod->MacroVisibilityLoc = ImportLoc;
3508     Mod->NameVisibility = NameVisibility;
3509 
3510     // If we've already deserialized any names from this module,
3511     // mark them as visible.
3512     HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3513     if (Hidden != HiddenNamesMap.end()) {
3514       auto HiddenNames = std::move(*Hidden);
3515       HiddenNamesMap.erase(Hidden);
3516       makeNamesVisible(HiddenNames.second, HiddenNames.first,
3517                        /*FromFinalization*/false);
3518       assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3519              "making names visible added hidden names");
3520     }
3521 
3522     // Push any exported modules onto the stack to be marked as visible.
3523     SmallVector<Module *, 16> Exports;
3524     Mod->getExportedModules(Exports);
3525     for (SmallVectorImpl<Module *>::iterator
3526            I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3527       Module *Exported = *I;
3528       if (Visited.insert(Exported).second)
3529         Stack.push_back(Exported);
3530     }
3531 
3532     // Detect any conflicts.
3533     if (Complain) {
3534       assert(ImportLoc.isValid() && "Missing import location");
3535       for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) {
3536         if (Mod->Conflicts[I].Other->NameVisibility >= NameVisibility) {
3537           Diag(ImportLoc, diag::warn_module_conflict)
3538             << Mod->getFullModuleName()
3539             << Mod->Conflicts[I].Other->getFullModuleName()
3540             << Mod->Conflicts[I].Message;
3541           // FIXME: Need note where the other module was imported.
3542         }
3543       }
3544     }
3545   }
3546 }
3547 
3548 bool ASTReader::loadGlobalIndex() {
3549   if (GlobalIndex)
3550     return false;
3551 
3552   if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3553       !Context.getLangOpts().Modules)
3554     return true;
3555 
3556   // Try to load the global index.
3557   TriedLoadingGlobalIndex = true;
3558   StringRef ModuleCachePath
3559     = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3560   std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3561     = GlobalModuleIndex::readIndex(ModuleCachePath);
3562   if (!Result.first)
3563     return true;
3564 
3565   GlobalIndex.reset(Result.first);
3566   ModuleMgr.setGlobalIndex(GlobalIndex.get());
3567   return false;
3568 }
3569 
3570 bool ASTReader::isGlobalIndexUnavailable() const {
3571   return Context.getLangOpts().Modules && UseGlobalIndex &&
3572          !hasGlobalIndex() && TriedLoadingGlobalIndex;
3573 }
3574 
3575 static void updateModuleTimestamp(ModuleFile &MF) {
3576   // Overwrite the timestamp file contents so that file's mtime changes.
3577   std::string TimestampFilename = MF.getTimestampFilename();
3578   std::error_code EC;
3579   llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3580   if (EC)
3581     return;
3582   OS << "Timestamp file\n";
3583 }
3584 
3585 ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
3586                                             ModuleKind Type,
3587                                             SourceLocation ImportLoc,
3588                                             unsigned ClientLoadCapabilities) {
3589   llvm::SaveAndRestore<SourceLocation>
3590     SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3591 
3592   // Defer any pending actions until we get to the end of reading the AST file.
3593   Deserializing AnASTFile(this);
3594 
3595   // Bump the generation number.
3596   unsigned PreviousGeneration = incrementGeneration(Context);
3597 
3598   unsigned NumModules = ModuleMgr.size();
3599   SmallVector<ImportedModule, 4> Loaded;
3600   switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
3601                                                 /*ImportedBy=*/nullptr, Loaded,
3602                                                 0, 0, 0,
3603                                                 ClientLoadCapabilities)) {
3604   case Failure:
3605   case Missing:
3606   case OutOfDate:
3607   case VersionMismatch:
3608   case ConfigurationMismatch:
3609   case HadErrors: {
3610     llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3611     for (const ImportedModule &IM : Loaded)
3612       LoadedSet.insert(IM.Mod);
3613 
3614     ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
3615                             LoadedSet,
3616                             Context.getLangOpts().Modules
3617                               ? &PP.getHeaderSearchInfo().getModuleMap()
3618                               : nullptr);
3619 
3620     // If we find that any modules are unusable, the global index is going
3621     // to be out-of-date. Just remove it.
3622     GlobalIndex.reset();
3623     ModuleMgr.setGlobalIndex(nullptr);
3624     return ReadResult;
3625   }
3626   case Success:
3627     break;
3628   }
3629 
3630   // Here comes stuff that we only do once the entire chain is loaded.
3631 
3632   // Load the AST blocks of all of the modules that we loaded.
3633   for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3634                                               MEnd = Loaded.end();
3635        M != MEnd; ++M) {
3636     ModuleFile &F = *M->Mod;
3637 
3638     // Read the AST block.
3639     if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3640       return Result;
3641 
3642     // Once read, set the ModuleFile bit base offset and update the size in
3643     // bits of all files we've seen.
3644     F.GlobalBitOffset = TotalModulesSizeInBits;
3645     TotalModulesSizeInBits += F.SizeInBits;
3646     GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3647 
3648     // Preload SLocEntries.
3649     for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3650       int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3651       // Load it through the SourceManager and don't call ReadSLocEntry()
3652       // directly because the entry may have already been loaded in which case
3653       // calling ReadSLocEntry() directly would trigger an assertion in
3654       // SourceManager.
3655       SourceMgr.getLoadedSLocEntryByID(Index);
3656     }
3657   }
3658 
3659   // Setup the import locations and notify the module manager that we've
3660   // committed to these module files.
3661   for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3662                                               MEnd = Loaded.end();
3663        M != MEnd; ++M) {
3664     ModuleFile &F = *M->Mod;
3665 
3666     ModuleMgr.moduleFileAccepted(&F);
3667 
3668     // Set the import location.
3669     F.DirectImportLoc = ImportLoc;
3670     if (!M->ImportedBy)
3671       F.ImportLoc = M->ImportLoc;
3672     else
3673       F.ImportLoc = ReadSourceLocation(*M->ImportedBy,
3674                                        M->ImportLoc.getRawEncoding());
3675   }
3676 
3677   // Mark all of the identifiers in the identifier table as being out of date,
3678   // so that various accessors know to check the loaded modules when the
3679   // identifier is used.
3680   for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3681                               IdEnd = PP.getIdentifierTable().end();
3682        Id != IdEnd; ++Id)
3683     Id->second->setOutOfDate(true);
3684 
3685   // Resolve any unresolved module exports.
3686   for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3687     UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3688     SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3689     Module *ResolvedMod = getSubmodule(GlobalID);
3690 
3691     switch (Unresolved.Kind) {
3692     case UnresolvedModuleRef::Conflict:
3693       if (ResolvedMod) {
3694         Module::Conflict Conflict;
3695         Conflict.Other = ResolvedMod;
3696         Conflict.Message = Unresolved.String.str();
3697         Unresolved.Mod->Conflicts.push_back(Conflict);
3698       }
3699       continue;
3700 
3701     case UnresolvedModuleRef::Import:
3702       if (ResolvedMod)
3703         Unresolved.Mod->Imports.push_back(ResolvedMod);
3704       continue;
3705 
3706     case UnresolvedModuleRef::Export:
3707       if (ResolvedMod || Unresolved.IsWildcard)
3708         Unresolved.Mod->Exports.push_back(
3709           Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3710       continue;
3711     }
3712   }
3713   UnresolvedModuleRefs.clear();
3714 
3715   // FIXME: How do we load the 'use'd modules? They may not be submodules.
3716   // Might be unnecessary as use declarations are only used to build the
3717   // module itself.
3718 
3719   InitializeContext();
3720 
3721   if (SemaObj)
3722     UpdateSema();
3723 
3724   if (DeserializationListener)
3725     DeserializationListener->ReaderInitialized(this);
3726 
3727   ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3728   if (!PrimaryModule.OriginalSourceFileID.isInvalid()) {
3729     PrimaryModule.OriginalSourceFileID
3730       = FileID::get(PrimaryModule.SLocEntryBaseID
3731                     + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
3732 
3733     // If this AST file is a precompiled preamble, then set the
3734     // preamble file ID of the source manager to the file source file
3735     // from which the preamble was built.
3736     if (Type == MK_Preamble) {
3737       SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3738     } else if (Type == MK_MainFile) {
3739       SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3740     }
3741   }
3742 
3743   // For any Objective-C class definitions we have already loaded, make sure
3744   // that we load any additional categories.
3745   for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3746     loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3747                        ObjCClassesLoaded[I],
3748                        PreviousGeneration);
3749   }
3750 
3751   if (PP.getHeaderSearchInfo()
3752           .getHeaderSearchOpts()
3753           .ModulesValidateOncePerBuildSession) {
3754     // Now we are certain that the module and all modules it depends on are
3755     // up to date.  Create or update timestamp files for modules that are
3756     // located in the module cache (not for PCH files that could be anywhere
3757     // in the filesystem).
3758     for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3759       ImportedModule &M = Loaded[I];
3760       if (M.Mod->Kind == MK_ImplicitModule) {
3761         updateModuleTimestamp(*M.Mod);
3762       }
3763     }
3764   }
3765 
3766   return Success;
3767 }
3768 
3769 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile);
3770 
3771 ASTReader::ASTReadResult
3772 ASTReader::ReadASTCore(StringRef FileName,
3773                        ModuleKind Type,
3774                        SourceLocation ImportLoc,
3775                        ModuleFile *ImportedBy,
3776                        SmallVectorImpl<ImportedModule> &Loaded,
3777                        off_t ExpectedSize, time_t ExpectedModTime,
3778                        ASTFileSignature ExpectedSignature,
3779                        unsigned ClientLoadCapabilities) {
3780   ModuleFile *M;
3781   std::string ErrorStr;
3782   ModuleManager::AddModuleResult AddResult
3783     = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
3784                           getGeneration(), ExpectedSize, ExpectedModTime,
3785                           ExpectedSignature, readASTFileSignature,
3786                           M, ErrorStr);
3787 
3788   switch (AddResult) {
3789   case ModuleManager::AlreadyLoaded:
3790     return Success;
3791 
3792   case ModuleManager::NewlyLoaded:
3793     // Load module file below.
3794     break;
3795 
3796   case ModuleManager::Missing:
3797     // The module file was missing; if the client can handle that, return
3798     // it.
3799     if (ClientLoadCapabilities & ARR_Missing)
3800       return Missing;
3801 
3802     // Otherwise, return an error.
3803     {
3804       std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
3805                       + ErrorStr;
3806       Error(Msg);
3807     }
3808     return Failure;
3809 
3810   case ModuleManager::OutOfDate:
3811     // We couldn't load the module file because it is out-of-date. If the
3812     // client can handle out-of-date, return it.
3813     if (ClientLoadCapabilities & ARR_OutOfDate)
3814       return OutOfDate;
3815 
3816     // Otherwise, return an error.
3817     {
3818       std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
3819                       + ErrorStr;
3820       Error(Msg);
3821     }
3822     return Failure;
3823   }
3824 
3825   assert(M && "Missing module file");
3826 
3827   // FIXME: This seems rather a hack. Should CurrentDir be part of the
3828   // module?
3829   if (FileName != "-") {
3830     CurrentDir = llvm::sys::path::parent_path(FileName);
3831     if (CurrentDir.empty()) CurrentDir = ".";
3832   }
3833 
3834   ModuleFile &F = *M;
3835   BitstreamCursor &Stream = F.Stream;
3836   Stream.init(&F.StreamFile);
3837   F.SizeInBits = F.Buffer->getBufferSize() * 8;
3838 
3839   // Sniff for the signature.
3840   if (Stream.Read(8) != 'C' ||
3841       Stream.Read(8) != 'P' ||
3842       Stream.Read(8) != 'C' ||
3843       Stream.Read(8) != 'H') {
3844     Diag(diag::err_not_a_pch_file) << FileName;
3845     return Failure;
3846   }
3847 
3848   // This is used for compatibility with older PCH formats.
3849   bool HaveReadControlBlock = false;
3850 
3851   while (1) {
3852     llvm::BitstreamEntry Entry = Stream.advance();
3853 
3854     switch (Entry.Kind) {
3855     case llvm::BitstreamEntry::Error:
3856     case llvm::BitstreamEntry::EndBlock:
3857     case llvm::BitstreamEntry::Record:
3858       Error("invalid record at top-level of AST file");
3859       return Failure;
3860 
3861     case llvm::BitstreamEntry::SubBlock:
3862       break;
3863     }
3864 
3865     // We only know the control subblock ID.
3866     switch (Entry.ID) {
3867     case llvm::bitc::BLOCKINFO_BLOCK_ID:
3868       if (Stream.ReadBlockInfoBlock()) {
3869         Error("malformed BlockInfoBlock in AST file");
3870         return Failure;
3871       }
3872       break;
3873     case CONTROL_BLOCK_ID:
3874       HaveReadControlBlock = true;
3875       switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
3876       case Success:
3877         break;
3878 
3879       case Failure: return Failure;
3880       case Missing: return Missing;
3881       case OutOfDate: return OutOfDate;
3882       case VersionMismatch: return VersionMismatch;
3883       case ConfigurationMismatch: return ConfigurationMismatch;
3884       case HadErrors: return HadErrors;
3885       }
3886       break;
3887     case AST_BLOCK_ID:
3888       if (!HaveReadControlBlock) {
3889         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3890           Diag(diag::err_pch_version_too_old);
3891         return VersionMismatch;
3892       }
3893 
3894       // Record that we've loaded this module.
3895       Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
3896       return Success;
3897 
3898     default:
3899       if (Stream.SkipBlock()) {
3900         Error("malformed block record in AST file");
3901         return Failure;
3902       }
3903       break;
3904     }
3905   }
3906 
3907   return Success;
3908 }
3909 
3910 void ASTReader::InitializeContext() {
3911   // If there's a listener, notify them that we "read" the translation unit.
3912   if (DeserializationListener)
3913     DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
3914                                       Context.getTranslationUnitDecl());
3915 
3916   // FIXME: Find a better way to deal with collisions between these
3917   // built-in types. Right now, we just ignore the problem.
3918 
3919   // Load the special types.
3920   if (SpecialTypes.size() >= NumSpecialTypeIDs) {
3921     if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3922       if (!Context.CFConstantStringTypeDecl)
3923         Context.setCFConstantStringType(GetType(String));
3924     }
3925 
3926     if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3927       QualType FileType = GetType(File);
3928       if (FileType.isNull()) {
3929         Error("FILE type is NULL");
3930         return;
3931       }
3932 
3933       if (!Context.FILEDecl) {
3934         if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3935           Context.setFILEDecl(Typedef->getDecl());
3936         else {
3937           const TagType *Tag = FileType->getAs<TagType>();
3938           if (!Tag) {
3939             Error("Invalid FILE type in AST file");
3940             return;
3941           }
3942           Context.setFILEDecl(Tag->getDecl());
3943         }
3944       }
3945     }
3946 
3947     if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
3948       QualType Jmp_bufType = GetType(Jmp_buf);
3949       if (Jmp_bufType.isNull()) {
3950         Error("jmp_buf type is NULL");
3951         return;
3952       }
3953 
3954       if (!Context.jmp_bufDecl) {
3955         if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3956           Context.setjmp_bufDecl(Typedef->getDecl());
3957         else {
3958           const TagType *Tag = Jmp_bufType->getAs<TagType>();
3959           if (!Tag) {
3960             Error("Invalid jmp_buf type in AST file");
3961             return;
3962           }
3963           Context.setjmp_bufDecl(Tag->getDecl());
3964         }
3965       }
3966     }
3967 
3968     if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
3969       QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3970       if (Sigjmp_bufType.isNull()) {
3971         Error("sigjmp_buf type is NULL");
3972         return;
3973       }
3974 
3975       if (!Context.sigjmp_bufDecl) {
3976         if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3977           Context.setsigjmp_bufDecl(Typedef->getDecl());
3978         else {
3979           const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
3980           assert(Tag && "Invalid sigjmp_buf type in AST file");
3981           Context.setsigjmp_bufDecl(Tag->getDecl());
3982         }
3983       }
3984     }
3985 
3986     if (unsigned ObjCIdRedef
3987           = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
3988       if (Context.ObjCIdRedefinitionType.isNull())
3989         Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
3990     }
3991 
3992     if (unsigned ObjCClassRedef
3993           = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
3994       if (Context.ObjCClassRedefinitionType.isNull())
3995         Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
3996     }
3997 
3998     if (unsigned ObjCSelRedef
3999           = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4000       if (Context.ObjCSelRedefinitionType.isNull())
4001         Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4002     }
4003 
4004     if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4005       QualType Ucontext_tType = GetType(Ucontext_t);
4006       if (Ucontext_tType.isNull()) {
4007         Error("ucontext_t type is NULL");
4008         return;
4009       }
4010 
4011       if (!Context.ucontext_tDecl) {
4012         if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4013           Context.setucontext_tDecl(Typedef->getDecl());
4014         else {
4015           const TagType *Tag = Ucontext_tType->getAs<TagType>();
4016           assert(Tag && "Invalid ucontext_t type in AST file");
4017           Context.setucontext_tDecl(Tag->getDecl());
4018         }
4019       }
4020     }
4021   }
4022 
4023   ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4024 
4025   // If there were any CUDA special declarations, deserialize them.
4026   if (!CUDASpecialDeclRefs.empty()) {
4027     assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4028     Context.setcudaConfigureCallDecl(
4029                            cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4030   }
4031 
4032   // Re-export any modules that were imported by a non-module AST file.
4033   // FIXME: This does not make macro-only imports visible again. It also doesn't
4034   // make #includes mapped to module imports visible.
4035   for (auto &Import : ImportedModules) {
4036     if (Module *Imported = getSubmodule(Import.ID))
4037       makeModuleVisible(Imported, Module::AllVisible,
4038                         /*ImportLoc=*/Import.ImportLoc,
4039                         /*Complain=*/false);
4040   }
4041   ImportedModules.clear();
4042 }
4043 
4044 void ASTReader::finalizeForWriting() {
4045   while (!HiddenNamesMap.empty()) {
4046     auto HiddenNames = std::move(*HiddenNamesMap.begin());
4047     HiddenNamesMap.erase(HiddenNamesMap.begin());
4048     makeNamesVisible(HiddenNames.second, HiddenNames.first,
4049                      /*FromFinalization*/true);
4050   }
4051 }
4052 
4053 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
4054 /// cursor into the start of the given block ID, returning false on success and
4055 /// true on failure.
4056 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
4057   while (1) {
4058     llvm::BitstreamEntry Entry = Cursor.advance();
4059     switch (Entry.Kind) {
4060     case llvm::BitstreamEntry::Error:
4061     case llvm::BitstreamEntry::EndBlock:
4062       return true;
4063 
4064     case llvm::BitstreamEntry::Record:
4065       // Ignore top-level records.
4066       Cursor.skipRecord(Entry.ID);
4067       break;
4068 
4069     case llvm::BitstreamEntry::SubBlock:
4070       if (Entry.ID == BlockID) {
4071         if (Cursor.EnterSubBlock(BlockID))
4072           return true;
4073         // Found it!
4074         return false;
4075       }
4076 
4077       if (Cursor.SkipBlock())
4078         return true;
4079     }
4080   }
4081 }
4082 
4083 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){
4084   BitstreamCursor Stream(StreamFile);
4085   if (Stream.Read(8) != 'C' ||
4086       Stream.Read(8) != 'P' ||
4087       Stream.Read(8) != 'C' ||
4088       Stream.Read(8) != 'H') {
4089     return 0;
4090   }
4091 
4092   // Scan for the CONTROL_BLOCK_ID block.
4093   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4094     return 0;
4095 
4096   // Scan for SIGNATURE inside the control block.
4097   ASTReader::RecordData Record;
4098   while (1) {
4099     llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4100     if (Entry.Kind == llvm::BitstreamEntry::EndBlock ||
4101         Entry.Kind != llvm::BitstreamEntry::Record)
4102       return 0;
4103 
4104     Record.clear();
4105     StringRef Blob;
4106     if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4107       return Record[0];
4108   }
4109 }
4110 
4111 /// \brief Retrieve the name of the original source file name
4112 /// directly from the AST file, without actually loading the AST
4113 /// file.
4114 std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
4115                                              FileManager &FileMgr,
4116                                              DiagnosticsEngine &Diags) {
4117   // Open the AST file.
4118   auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4119   if (!Buffer) {
4120     Diags.Report(diag::err_fe_unable_to_read_pch_file)
4121         << ASTFileName << Buffer.getError().message();
4122     return std::string();
4123   }
4124 
4125   // Initialize the stream
4126   llvm::BitstreamReader StreamFile;
4127   StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(),
4128                   (const unsigned char *)(*Buffer)->getBufferEnd());
4129   BitstreamCursor Stream(StreamFile);
4130 
4131   // Sniff for the signature.
4132   if (Stream.Read(8) != 'C' ||
4133       Stream.Read(8) != 'P' ||
4134       Stream.Read(8) != 'C' ||
4135       Stream.Read(8) != 'H') {
4136     Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4137     return std::string();
4138   }
4139 
4140   // Scan for the CONTROL_BLOCK_ID block.
4141   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4142     Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4143     return std::string();
4144   }
4145 
4146   // Scan for ORIGINAL_FILE inside the control block.
4147   RecordData Record;
4148   while (1) {
4149     llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4150     if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4151       return std::string();
4152 
4153     if (Entry.Kind != llvm::BitstreamEntry::Record) {
4154       Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4155       return std::string();
4156     }
4157 
4158     Record.clear();
4159     StringRef Blob;
4160     if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4161       return Blob.str();
4162   }
4163 }
4164 
4165 namespace {
4166   class SimplePCHValidator : public ASTReaderListener {
4167     const LangOptions &ExistingLangOpts;
4168     const TargetOptions &ExistingTargetOpts;
4169     const PreprocessorOptions &ExistingPPOpts;
4170     FileManager &FileMgr;
4171 
4172   public:
4173     SimplePCHValidator(const LangOptions &ExistingLangOpts,
4174                        const TargetOptions &ExistingTargetOpts,
4175                        const PreprocessorOptions &ExistingPPOpts,
4176                        FileManager &FileMgr)
4177       : ExistingLangOpts(ExistingLangOpts),
4178         ExistingTargetOpts(ExistingTargetOpts),
4179         ExistingPPOpts(ExistingPPOpts),
4180         FileMgr(FileMgr)
4181     {
4182     }
4183 
4184     bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4185                              bool AllowCompatibleDifferences) override {
4186       return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4187                                   AllowCompatibleDifferences);
4188     }
4189     bool ReadTargetOptions(const TargetOptions &TargetOpts,
4190                            bool Complain) override {
4191       return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr);
4192     }
4193     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4194                                  bool Complain,
4195                                  std::string &SuggestedPredefines) override {
4196       return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4197                                       SuggestedPredefines, ExistingLangOpts);
4198     }
4199   };
4200 }
4201 
4202 bool ASTReader::readASTFileControlBlock(StringRef Filename,
4203                                         FileManager &FileMgr,
4204                                         ASTReaderListener &Listener) {
4205   // Open the AST file.
4206   auto Buffer = FileMgr.getBufferForFile(Filename);
4207   if (!Buffer) {
4208     return true;
4209   }
4210 
4211   // Initialize the stream
4212   llvm::BitstreamReader StreamFile;
4213   StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(),
4214                   (const unsigned char *)(*Buffer)->getBufferEnd());
4215   BitstreamCursor Stream(StreamFile);
4216 
4217   // Sniff for the signature.
4218   if (Stream.Read(8) != 'C' ||
4219       Stream.Read(8) != 'P' ||
4220       Stream.Read(8) != 'C' ||
4221       Stream.Read(8) != 'H') {
4222     return true;
4223   }
4224 
4225   // Scan for the CONTROL_BLOCK_ID block.
4226   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4227     return true;
4228 
4229   bool NeedsInputFiles = Listener.needsInputFileVisitation();
4230   bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4231   bool NeedsImports = Listener.needsImportVisitation();
4232   BitstreamCursor InputFilesCursor;
4233   if (NeedsInputFiles) {
4234     InputFilesCursor = Stream;
4235     if (SkipCursorToBlock(InputFilesCursor, INPUT_FILES_BLOCK_ID))
4236       return true;
4237 
4238     // Read the abbreviations
4239     while (true) {
4240       uint64_t Offset = InputFilesCursor.GetCurrentBitNo();
4241       unsigned Code = InputFilesCursor.ReadCode();
4242 
4243       // We expect all abbrevs to be at the start of the block.
4244       if (Code != llvm::bitc::DEFINE_ABBREV) {
4245         InputFilesCursor.JumpToBit(Offset);
4246         break;
4247       }
4248       InputFilesCursor.ReadAbbrevRecord();
4249     }
4250   }
4251 
4252   // Scan for ORIGINAL_FILE inside the control block.
4253   RecordData Record;
4254   while (1) {
4255     llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4256     if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4257       return false;
4258 
4259     if (Entry.Kind != llvm::BitstreamEntry::Record)
4260       return true;
4261 
4262     Record.clear();
4263     StringRef Blob;
4264     unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4265     switch ((ControlRecordTypes)RecCode) {
4266     case METADATA: {
4267       if (Record[0] != VERSION_MAJOR)
4268         return true;
4269 
4270       if (Listener.ReadFullVersionInformation(Blob))
4271         return true;
4272 
4273       break;
4274     }
4275     case MODULE_NAME:
4276       Listener.ReadModuleName(Blob);
4277       break;
4278     case MODULE_MAP_FILE: {
4279       unsigned Idx = 0;
4280       Listener.ReadModuleMapFile(ReadString(Record, Idx));
4281       break;
4282     }
4283     case LANGUAGE_OPTIONS:
4284       if (ParseLanguageOptions(Record, false, Listener,
4285                                /*AllowCompatibleConfigurationMismatch*/false))
4286         return true;
4287       break;
4288 
4289     case TARGET_OPTIONS:
4290       if (ParseTargetOptions(Record, false, Listener))
4291         return true;
4292       break;
4293 
4294     case DIAGNOSTIC_OPTIONS:
4295       if (ParseDiagnosticOptions(Record, false, Listener))
4296         return true;
4297       break;
4298 
4299     case FILE_SYSTEM_OPTIONS:
4300       if (ParseFileSystemOptions(Record, false, Listener))
4301         return true;
4302       break;
4303 
4304     case HEADER_SEARCH_OPTIONS:
4305       if (ParseHeaderSearchOptions(Record, false, Listener))
4306         return true;
4307       break;
4308 
4309     case PREPROCESSOR_OPTIONS: {
4310       std::string IgnoredSuggestedPredefines;
4311       if (ParsePreprocessorOptions(Record, false, Listener,
4312                                    IgnoredSuggestedPredefines))
4313         return true;
4314       break;
4315     }
4316 
4317     case INPUT_FILE_OFFSETS: {
4318       if (!NeedsInputFiles)
4319         break;
4320 
4321       unsigned NumInputFiles = Record[0];
4322       unsigned NumUserFiles = Record[1];
4323       const uint32_t *InputFileOffs = (const uint32_t *)Blob.data();
4324       for (unsigned I = 0; I != NumInputFiles; ++I) {
4325         // Go find this input file.
4326         bool isSystemFile = I >= NumUserFiles;
4327 
4328         if (isSystemFile && !NeedsSystemInputFiles)
4329           break; // the rest are system input files
4330 
4331         BitstreamCursor &Cursor = InputFilesCursor;
4332         SavedStreamPosition SavedPosition(Cursor);
4333         Cursor.JumpToBit(InputFileOffs[I]);
4334 
4335         unsigned Code = Cursor.ReadCode();
4336         RecordData Record;
4337         StringRef Blob;
4338         bool shouldContinue = false;
4339         switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4340         case INPUT_FILE:
4341           bool Overridden = static_cast<bool>(Record[3]);
4342           shouldContinue = Listener.visitInputFile(Blob, isSystemFile, Overridden);
4343           break;
4344         }
4345         if (!shouldContinue)
4346           break;
4347       }
4348       break;
4349     }
4350 
4351     case IMPORTS: {
4352       if (!NeedsImports)
4353         break;
4354 
4355       unsigned Idx = 0, N = Record.size();
4356       while (Idx < N) {
4357         // Read information about the AST file.
4358         Idx += 5; // ImportLoc, Size, ModTime, Signature
4359         unsigned Length = Record[Idx++];
4360         SmallString<128> ImportedFile(Record.begin() + Idx,
4361                                       Record.begin() + Idx + Length);
4362         Idx += Length;
4363         Listener.visitImport(ImportedFile);
4364       }
4365       break;
4366     }
4367 
4368     default:
4369       // No other validation to perform.
4370       break;
4371     }
4372   }
4373 }
4374 
4375 
4376 bool ASTReader::isAcceptableASTFile(StringRef Filename,
4377                                     FileManager &FileMgr,
4378                                     const LangOptions &LangOpts,
4379                                     const TargetOptions &TargetOpts,
4380                                     const PreprocessorOptions &PPOpts) {
4381   SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, FileMgr);
4382   return !readASTFileControlBlock(Filename, FileMgr, validator);
4383 }
4384 
4385 ASTReader::ASTReadResult
4386 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4387   // Enter the submodule block.
4388   if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4389     Error("malformed submodule block record in AST file");
4390     return Failure;
4391   }
4392 
4393   ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4394   bool First = true;
4395   Module *CurrentModule = nullptr;
4396   RecordData Record;
4397   while (true) {
4398     llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4399 
4400     switch (Entry.Kind) {
4401     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4402     case llvm::BitstreamEntry::Error:
4403       Error("malformed block record in AST file");
4404       return Failure;
4405     case llvm::BitstreamEntry::EndBlock:
4406       return Success;
4407     case llvm::BitstreamEntry::Record:
4408       // The interesting case.
4409       break;
4410     }
4411 
4412     // Read a record.
4413     StringRef Blob;
4414     Record.clear();
4415     auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4416 
4417     if ((Kind == SUBMODULE_METADATA) != First) {
4418       Error("submodule metadata record should be at beginning of block");
4419       return Failure;
4420     }
4421     First = false;
4422 
4423     // Submodule information is only valid if we have a current module.
4424     // FIXME: Should we error on these cases?
4425     if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4426         Kind != SUBMODULE_DEFINITION)
4427       continue;
4428 
4429     switch (Kind) {
4430     default:  // Default behavior: ignore.
4431       break;
4432 
4433     case SUBMODULE_DEFINITION: {
4434       if (Record.size() < 8) {
4435         Error("malformed module definition");
4436         return Failure;
4437       }
4438 
4439       StringRef Name = Blob;
4440       unsigned Idx = 0;
4441       SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4442       SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4443       bool IsFramework = Record[Idx++];
4444       bool IsExplicit = Record[Idx++];
4445       bool IsSystem = Record[Idx++];
4446       bool IsExternC = Record[Idx++];
4447       bool InferSubmodules = Record[Idx++];
4448       bool InferExplicitSubmodules = Record[Idx++];
4449       bool InferExportWildcard = Record[Idx++];
4450       bool ConfigMacrosExhaustive = Record[Idx++];
4451 
4452       Module *ParentModule = nullptr;
4453       if (Parent)
4454         ParentModule = getSubmodule(Parent);
4455 
4456       // Retrieve this (sub)module from the module map, creating it if
4457       // necessary.
4458       CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
4459                                                 IsExplicit).first;
4460 
4461       // FIXME: set the definition loc for CurrentModule, or call
4462       // ModMap.setInferredModuleAllowedBy()
4463 
4464       SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4465       if (GlobalIndex >= SubmodulesLoaded.size() ||
4466           SubmodulesLoaded[GlobalIndex]) {
4467         Error("too many submodules");
4468         return Failure;
4469       }
4470 
4471       if (!ParentModule) {
4472         if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4473           if (CurFile != F.File) {
4474             if (!Diags.isDiagnosticInFlight()) {
4475               Diag(diag::err_module_file_conflict)
4476                 << CurrentModule->getTopLevelModuleName()
4477                 << CurFile->getName()
4478                 << F.File->getName();
4479             }
4480             return Failure;
4481           }
4482         }
4483 
4484         CurrentModule->setASTFile(F.File);
4485       }
4486 
4487       CurrentModule->IsFromModuleFile = true;
4488       CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
4489       CurrentModule->IsExternC = IsExternC;
4490       CurrentModule->InferSubmodules = InferSubmodules;
4491       CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4492       CurrentModule->InferExportWildcard = InferExportWildcard;
4493       CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
4494       if (DeserializationListener)
4495         DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4496 
4497       SubmodulesLoaded[GlobalIndex] = CurrentModule;
4498 
4499       // Clear out data that will be replaced by what is the module file.
4500       CurrentModule->LinkLibraries.clear();
4501       CurrentModule->ConfigMacros.clear();
4502       CurrentModule->UnresolvedConflicts.clear();
4503       CurrentModule->Conflicts.clear();
4504       break;
4505     }
4506 
4507     case SUBMODULE_UMBRELLA_HEADER: {
4508       if (const FileEntry *Umbrella = PP.getFileManager().getFile(Blob)) {
4509         if (!CurrentModule->getUmbrellaHeader())
4510           ModMap.setUmbrellaHeader(CurrentModule, Umbrella);
4511         else if (CurrentModule->getUmbrellaHeader() != Umbrella) {
4512           if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4513             Error("mismatched umbrella headers in submodule");
4514           return OutOfDate;
4515         }
4516       }
4517       break;
4518     }
4519 
4520     case SUBMODULE_HEADER:
4521     case SUBMODULE_EXCLUDED_HEADER:
4522     case SUBMODULE_PRIVATE_HEADER:
4523       // We lazily associate headers with their modules via the HeaderInfo table.
4524       // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4525       // of complete filenames or remove it entirely.
4526       break;
4527 
4528     case SUBMODULE_TEXTUAL_HEADER:
4529     case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
4530       // FIXME: Textual headers are not marked in the HeaderInfo table. Load
4531       // them here.
4532       break;
4533 
4534     case SUBMODULE_TOPHEADER: {
4535       CurrentModule->addTopHeaderFilename(Blob);
4536       break;
4537     }
4538 
4539     case SUBMODULE_UMBRELLA_DIR: {
4540       if (const DirectoryEntry *Umbrella
4541                                   = PP.getFileManager().getDirectory(Blob)) {
4542         if (!CurrentModule->getUmbrellaDir())
4543           ModMap.setUmbrellaDir(CurrentModule, Umbrella);
4544         else if (CurrentModule->getUmbrellaDir() != Umbrella) {
4545           if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4546             Error("mismatched umbrella directories in submodule");
4547           return OutOfDate;
4548         }
4549       }
4550       break;
4551     }
4552 
4553     case SUBMODULE_METADATA: {
4554       F.BaseSubmoduleID = getTotalNumSubmodules();
4555       F.LocalNumSubmodules = Record[0];
4556       unsigned LocalBaseSubmoduleID = Record[1];
4557       if (F.LocalNumSubmodules > 0) {
4558         // Introduce the global -> local mapping for submodules within this
4559         // module.
4560         GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
4561 
4562         // Introduce the local -> global mapping for submodules within this
4563         // module.
4564         F.SubmoduleRemap.insertOrReplace(
4565           std::make_pair(LocalBaseSubmoduleID,
4566                          F.BaseSubmoduleID - LocalBaseSubmoduleID));
4567 
4568         SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
4569       }
4570       break;
4571     }
4572 
4573     case SUBMODULE_IMPORTS: {
4574       for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
4575         UnresolvedModuleRef Unresolved;
4576         Unresolved.File = &F;
4577         Unresolved.Mod = CurrentModule;
4578         Unresolved.ID = Record[Idx];
4579         Unresolved.Kind = UnresolvedModuleRef::Import;
4580         Unresolved.IsWildcard = false;
4581         UnresolvedModuleRefs.push_back(Unresolved);
4582       }
4583       break;
4584     }
4585 
4586     case SUBMODULE_EXPORTS: {
4587       for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
4588         UnresolvedModuleRef Unresolved;
4589         Unresolved.File = &F;
4590         Unresolved.Mod = CurrentModule;
4591         Unresolved.ID = Record[Idx];
4592         Unresolved.Kind = UnresolvedModuleRef::Export;
4593         Unresolved.IsWildcard = Record[Idx + 1];
4594         UnresolvedModuleRefs.push_back(Unresolved);
4595       }
4596 
4597       // Once we've loaded the set of exports, there's no reason to keep
4598       // the parsed, unresolved exports around.
4599       CurrentModule->UnresolvedExports.clear();
4600       break;
4601     }
4602     case SUBMODULE_REQUIRES: {
4603       CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
4604                                     Context.getTargetInfo());
4605       break;
4606     }
4607 
4608     case SUBMODULE_LINK_LIBRARY:
4609       CurrentModule->LinkLibraries.push_back(
4610                                          Module::LinkLibrary(Blob, Record[0]));
4611       break;
4612 
4613     case SUBMODULE_CONFIG_MACRO:
4614       CurrentModule->ConfigMacros.push_back(Blob.str());
4615       break;
4616 
4617     case SUBMODULE_CONFLICT: {
4618       UnresolvedModuleRef Unresolved;
4619       Unresolved.File = &F;
4620       Unresolved.Mod = CurrentModule;
4621       Unresolved.ID = Record[0];
4622       Unresolved.Kind = UnresolvedModuleRef::Conflict;
4623       Unresolved.IsWildcard = false;
4624       Unresolved.String = Blob;
4625       UnresolvedModuleRefs.push_back(Unresolved);
4626       break;
4627     }
4628     }
4629   }
4630 }
4631 
4632 /// \brief Parse the record that corresponds to a LangOptions data
4633 /// structure.
4634 ///
4635 /// This routine parses the language options from the AST file and then gives
4636 /// them to the AST listener if one is set.
4637 ///
4638 /// \returns true if the listener deems the file unacceptable, false otherwise.
4639 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
4640                                      bool Complain,
4641                                      ASTReaderListener &Listener,
4642                                      bool AllowCompatibleDifferences) {
4643   LangOptions LangOpts;
4644   unsigned Idx = 0;
4645 #define LANGOPT(Name, Bits, Default, Description) \
4646   LangOpts.Name = Record[Idx++];
4647 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4648   LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
4649 #include "clang/Basic/LangOptions.def"
4650 #define SANITIZER(NAME, ID)                                                    \
4651   LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
4652 #include "clang/Basic/Sanitizers.def"
4653 
4654   ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
4655   VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
4656   LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
4657 
4658   unsigned Length = Record[Idx++];
4659   LangOpts.CurrentModule.assign(Record.begin() + Idx,
4660                                 Record.begin() + Idx + Length);
4661 
4662   Idx += Length;
4663 
4664   // Comment options.
4665   for (unsigned N = Record[Idx++]; N; --N) {
4666     LangOpts.CommentOpts.BlockCommandNames.push_back(
4667       ReadString(Record, Idx));
4668   }
4669   LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
4670 
4671   return Listener.ReadLanguageOptions(LangOpts, Complain,
4672                                       AllowCompatibleDifferences);
4673 }
4674 
4675 bool ASTReader::ParseTargetOptions(const RecordData &Record,
4676                                    bool Complain,
4677                                    ASTReaderListener &Listener) {
4678   unsigned Idx = 0;
4679   TargetOptions TargetOpts;
4680   TargetOpts.Triple = ReadString(Record, Idx);
4681   TargetOpts.CPU = ReadString(Record, Idx);
4682   TargetOpts.ABI = ReadString(Record, Idx);
4683   for (unsigned N = Record[Idx++]; N; --N) {
4684     TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
4685   }
4686   for (unsigned N = Record[Idx++]; N; --N) {
4687     TargetOpts.Features.push_back(ReadString(Record, Idx));
4688   }
4689 
4690   return Listener.ReadTargetOptions(TargetOpts, Complain);
4691 }
4692 
4693 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
4694                                        ASTReaderListener &Listener) {
4695   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
4696   unsigned Idx = 0;
4697 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
4698 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4699   DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
4700 #include "clang/Basic/DiagnosticOptions.def"
4701 
4702   for (unsigned N = Record[Idx++]; N; --N)
4703     DiagOpts->Warnings.push_back(ReadString(Record, Idx));
4704   for (unsigned N = Record[Idx++]; N; --N)
4705     DiagOpts->Remarks.push_back(ReadString(Record, Idx));
4706 
4707   return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
4708 }
4709 
4710 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
4711                                        ASTReaderListener &Listener) {
4712   FileSystemOptions FSOpts;
4713   unsigned Idx = 0;
4714   FSOpts.WorkingDir = ReadString(Record, Idx);
4715   return Listener.ReadFileSystemOptions(FSOpts, Complain);
4716 }
4717 
4718 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
4719                                          bool Complain,
4720                                          ASTReaderListener &Listener) {
4721   HeaderSearchOptions HSOpts;
4722   unsigned Idx = 0;
4723   HSOpts.Sysroot = ReadString(Record, Idx);
4724 
4725   // Include entries.
4726   for (unsigned N = Record[Idx++]; N; --N) {
4727     std::string Path = ReadString(Record, Idx);
4728     frontend::IncludeDirGroup Group
4729       = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
4730     bool IsFramework = Record[Idx++];
4731     bool IgnoreSysRoot = Record[Idx++];
4732     HSOpts.UserEntries.push_back(
4733       HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot));
4734   }
4735 
4736   // System header prefixes.
4737   for (unsigned N = Record[Idx++]; N; --N) {
4738     std::string Prefix = ReadString(Record, Idx);
4739     bool IsSystemHeader = Record[Idx++];
4740     HSOpts.SystemHeaderPrefixes.push_back(
4741       HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader));
4742   }
4743 
4744   HSOpts.ResourceDir = ReadString(Record, Idx);
4745   HSOpts.ModuleCachePath = ReadString(Record, Idx);
4746   HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
4747   HSOpts.DisableModuleHash = Record[Idx++];
4748   HSOpts.UseBuiltinIncludes = Record[Idx++];
4749   HSOpts.UseStandardSystemIncludes = Record[Idx++];
4750   HSOpts.UseStandardCXXIncludes = Record[Idx++];
4751   HSOpts.UseLibcxx = Record[Idx++];
4752 
4753   return Listener.ReadHeaderSearchOptions(HSOpts, Complain);
4754 }
4755 
4756 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
4757                                          bool Complain,
4758                                          ASTReaderListener &Listener,
4759                                          std::string &SuggestedPredefines) {
4760   PreprocessorOptions PPOpts;
4761   unsigned Idx = 0;
4762 
4763   // Macro definitions/undefs
4764   for (unsigned N = Record[Idx++]; N; --N) {
4765     std::string Macro = ReadString(Record, Idx);
4766     bool IsUndef = Record[Idx++];
4767     PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
4768   }
4769 
4770   // Includes
4771   for (unsigned N = Record[Idx++]; N; --N) {
4772     PPOpts.Includes.push_back(ReadString(Record, Idx));
4773   }
4774 
4775   // Macro Includes
4776   for (unsigned N = Record[Idx++]; N; --N) {
4777     PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
4778   }
4779 
4780   PPOpts.UsePredefines = Record[Idx++];
4781   PPOpts.DetailedRecord = Record[Idx++];
4782   PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
4783   PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
4784   PPOpts.ObjCXXARCStandardLibrary =
4785     static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
4786   SuggestedPredefines.clear();
4787   return Listener.ReadPreprocessorOptions(PPOpts, Complain,
4788                                           SuggestedPredefines);
4789 }
4790 
4791 std::pair<ModuleFile *, unsigned>
4792 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
4793   GlobalPreprocessedEntityMapType::iterator
4794   I = GlobalPreprocessedEntityMap.find(GlobalIndex);
4795   assert(I != GlobalPreprocessedEntityMap.end() &&
4796          "Corrupted global preprocessed entity map");
4797   ModuleFile *M = I->second;
4798   unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
4799   return std::make_pair(M, LocalIndex);
4800 }
4801 
4802 std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
4803 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
4804   if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
4805     return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
4806                                              Mod.NumPreprocessedEntities);
4807 
4808   return std::make_pair(PreprocessingRecord::iterator(),
4809                         PreprocessingRecord::iterator());
4810 }
4811 
4812 std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator>
4813 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
4814   return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
4815                         ModuleDeclIterator(this, &Mod,
4816                                  Mod.FileSortedDecls + Mod.NumFileSortedDecls));
4817 }
4818 
4819 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
4820   PreprocessedEntityID PPID = Index+1;
4821   std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4822   ModuleFile &M = *PPInfo.first;
4823   unsigned LocalIndex = PPInfo.second;
4824   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4825 
4826   if (!PP.getPreprocessingRecord()) {
4827     Error("no preprocessing record");
4828     return nullptr;
4829   }
4830 
4831   SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
4832   M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
4833 
4834   llvm::BitstreamEntry Entry =
4835     M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
4836   if (Entry.Kind != llvm::BitstreamEntry::Record)
4837     return nullptr;
4838 
4839   // Read the record.
4840   SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
4841                     ReadSourceLocation(M, PPOffs.End));
4842   PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
4843   StringRef Blob;
4844   RecordData Record;
4845   PreprocessorDetailRecordTypes RecType =
4846     (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
4847                                           Entry.ID, Record, &Blob);
4848   switch (RecType) {
4849   case PPD_MACRO_EXPANSION: {
4850     bool isBuiltin = Record[0];
4851     IdentifierInfo *Name = nullptr;
4852     MacroDefinition *Def = nullptr;
4853     if (isBuiltin)
4854       Name = getLocalIdentifier(M, Record[1]);
4855     else {
4856       PreprocessedEntityID
4857           GlobalID = getGlobalPreprocessedEntityID(M, Record[1]);
4858       Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1));
4859     }
4860 
4861     MacroExpansion *ME;
4862     if (isBuiltin)
4863       ME = new (PPRec) MacroExpansion(Name, Range);
4864     else
4865       ME = new (PPRec) MacroExpansion(Def, Range);
4866 
4867     return ME;
4868   }
4869 
4870   case PPD_MACRO_DEFINITION: {
4871     // Decode the identifier info and then check again; if the macro is
4872     // still defined and associated with the identifier,
4873     IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
4874     MacroDefinition *MD
4875       = new (PPRec) MacroDefinition(II, Range);
4876 
4877     if (DeserializationListener)
4878       DeserializationListener->MacroDefinitionRead(PPID, MD);
4879 
4880     return MD;
4881   }
4882 
4883   case PPD_INCLUSION_DIRECTIVE: {
4884     const char *FullFileNameStart = Blob.data() + Record[0];
4885     StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
4886     const FileEntry *File = nullptr;
4887     if (!FullFileName.empty())
4888       File = PP.getFileManager().getFile(FullFileName);
4889 
4890     // FIXME: Stable encoding
4891     InclusionDirective::InclusionKind Kind
4892       = static_cast<InclusionDirective::InclusionKind>(Record[2]);
4893     InclusionDirective *ID
4894       = new (PPRec) InclusionDirective(PPRec, Kind,
4895                                        StringRef(Blob.data(), Record[0]),
4896                                        Record[1], Record[3],
4897                                        File,
4898                                        Range);
4899     return ID;
4900   }
4901   }
4902 
4903   llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
4904 }
4905 
4906 /// \brief \arg SLocMapI points at a chunk of a module that contains no
4907 /// preprocessed entities or the entities it contains are not the ones we are
4908 /// looking for. Find the next module that contains entities and return the ID
4909 /// of the first entry.
4910 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
4911                        GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
4912   ++SLocMapI;
4913   for (GlobalSLocOffsetMapType::const_iterator
4914          EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
4915     ModuleFile &M = *SLocMapI->second;
4916     if (M.NumPreprocessedEntities)
4917       return M.BasePreprocessedEntityID;
4918   }
4919 
4920   return getTotalNumPreprocessedEntities();
4921 }
4922 
4923 namespace {
4924 
4925 template <unsigned PPEntityOffset::*PPLoc>
4926 struct PPEntityComp {
4927   const ASTReader &Reader;
4928   ModuleFile &M;
4929 
4930   PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
4931 
4932   bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4933     SourceLocation LHS = getLoc(L);
4934     SourceLocation RHS = getLoc(R);
4935     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4936   }
4937 
4938   bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
4939     SourceLocation LHS = getLoc(L);
4940     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4941   }
4942 
4943   bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
4944     SourceLocation RHS = getLoc(R);
4945     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4946   }
4947 
4948   SourceLocation getLoc(const PPEntityOffset &PPE) const {
4949     return Reader.ReadSourceLocation(M, PPE.*PPLoc);
4950   }
4951 };
4952 
4953 }
4954 
4955 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
4956                                                        bool EndsAfter) const {
4957   if (SourceMgr.isLocalSourceLocation(Loc))
4958     return getTotalNumPreprocessedEntities();
4959 
4960   GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
4961       SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
4962   assert(SLocMapI != GlobalSLocOffsetMap.end() &&
4963          "Corrupted global sloc offset map");
4964 
4965   if (SLocMapI->second->NumPreprocessedEntities == 0)
4966     return findNextPreprocessedEntity(SLocMapI);
4967 
4968   ModuleFile &M = *SLocMapI->second;
4969   typedef const PPEntityOffset *pp_iterator;
4970   pp_iterator pp_begin = M.PreprocessedEntityOffsets;
4971   pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
4972 
4973   size_t Count = M.NumPreprocessedEntities;
4974   size_t Half;
4975   pp_iterator First = pp_begin;
4976   pp_iterator PPI;
4977 
4978   if (EndsAfter) {
4979     PPI = std::upper_bound(pp_begin, pp_end, Loc,
4980                            PPEntityComp<&PPEntityOffset::Begin>(*this, M));
4981   } else {
4982     // Do a binary search manually instead of using std::lower_bound because
4983     // The end locations of entities may be unordered (when a macro expansion
4984     // is inside another macro argument), but for this case it is not important
4985     // whether we get the first macro expansion or its containing macro.
4986     while (Count > 0) {
4987       Half = Count / 2;
4988       PPI = First;
4989       std::advance(PPI, Half);
4990       if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
4991                                               Loc)) {
4992         First = PPI;
4993         ++First;
4994         Count = Count - Half - 1;
4995       } else
4996         Count = Half;
4997     }
4998   }
4999 
5000   if (PPI == pp_end)
5001     return findNextPreprocessedEntity(SLocMapI);
5002 
5003   return M.BasePreprocessedEntityID + (PPI - pp_begin);
5004 }
5005 
5006 /// \brief Returns a pair of [Begin, End) indices of preallocated
5007 /// preprocessed entities that \arg Range encompasses.
5008 std::pair<unsigned, unsigned>
5009     ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5010   if (Range.isInvalid())
5011     return std::make_pair(0,0);
5012   assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5013 
5014   PreprocessedEntityID BeginID =
5015       findPreprocessedEntity(Range.getBegin(), false);
5016   PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5017   return std::make_pair(BeginID, EndID);
5018 }
5019 
5020 /// \brief Optionally returns true or false if the preallocated preprocessed
5021 /// entity with index \arg Index came from file \arg FID.
5022 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5023                                                              FileID FID) {
5024   if (FID.isInvalid())
5025     return false;
5026 
5027   std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5028   ModuleFile &M = *PPInfo.first;
5029   unsigned LocalIndex = PPInfo.second;
5030   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5031 
5032   SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
5033   if (Loc.isInvalid())
5034     return false;
5035 
5036   if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5037     return true;
5038   else
5039     return false;
5040 }
5041 
5042 namespace {
5043   /// \brief Visitor used to search for information about a header file.
5044   class HeaderFileInfoVisitor {
5045     const FileEntry *FE;
5046 
5047     Optional<HeaderFileInfo> HFI;
5048 
5049   public:
5050     explicit HeaderFileInfoVisitor(const FileEntry *FE)
5051       : FE(FE) { }
5052 
5053     static bool visit(ModuleFile &M, void *UserData) {
5054       HeaderFileInfoVisitor *This
5055         = static_cast<HeaderFileInfoVisitor *>(UserData);
5056 
5057       HeaderFileInfoLookupTable *Table
5058         = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5059       if (!Table)
5060         return false;
5061 
5062       // Look in the on-disk hash table for an entry for this file name.
5063       HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE);
5064       if (Pos == Table->end())
5065         return false;
5066 
5067       This->HFI = *Pos;
5068       return true;
5069     }
5070 
5071     Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5072   };
5073 }
5074 
5075 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5076   HeaderFileInfoVisitor Visitor(FE);
5077   ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
5078   if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5079     return *HFI;
5080 
5081   return HeaderFileInfo();
5082 }
5083 
5084 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5085   // FIXME: Make it work properly with modules.
5086   SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
5087   for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
5088     ModuleFile &F = *(*I);
5089     unsigned Idx = 0;
5090     DiagStates.clear();
5091     assert(!Diag.DiagStates.empty());
5092     DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
5093     while (Idx < F.PragmaDiagMappings.size()) {
5094       SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5095       unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
5096       if (DiagStateID != 0) {
5097         Diag.DiagStatePoints.push_back(
5098                     DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
5099                     FullSourceLoc(Loc, SourceMgr)));
5100         continue;
5101       }
5102 
5103       assert(DiagStateID == 0);
5104       // A new DiagState was created here.
5105       Diag.DiagStates.push_back(*Diag.GetCurDiagState());
5106       DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
5107       DiagStates.push_back(NewState);
5108       Diag.DiagStatePoints.push_back(
5109           DiagnosticsEngine::DiagStatePoint(NewState,
5110                                             FullSourceLoc(Loc, SourceMgr)));
5111       while (1) {
5112         assert(Idx < F.PragmaDiagMappings.size() &&
5113                "Invalid data, didn't find '-1' marking end of diag/map pairs");
5114         if (Idx >= F.PragmaDiagMappings.size()) {
5115           break; // Something is messed up but at least avoid infinite loop in
5116                  // release build.
5117         }
5118         unsigned DiagID = F.PragmaDiagMappings[Idx++];
5119         if (DiagID == (unsigned)-1) {
5120           break; // no more diag/map pairs for this location.
5121         }
5122         diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
5123         DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
5124         Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
5125       }
5126     }
5127   }
5128 }
5129 
5130 /// \brief Get the correct cursor and offset for loading a type.
5131 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5132   GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5133   assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5134   ModuleFile *M = I->second;
5135   return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5136 }
5137 
5138 /// \brief Read and return the type with the given index..
5139 ///
5140 /// The index is the type ID, shifted and minus the number of predefs. This
5141 /// routine actually reads the record corresponding to the type at the given
5142 /// location. It is a helper routine for GetType, which deals with reading type
5143 /// IDs.
5144 QualType ASTReader::readTypeRecord(unsigned Index) {
5145   RecordLocation Loc = TypeCursorForIndex(Index);
5146   BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5147 
5148   // Keep track of where we are in the stream, then jump back there
5149   // after reading this type.
5150   SavedStreamPosition SavedPosition(DeclsCursor);
5151 
5152   ReadingKindTracker ReadingKind(Read_Type, *this);
5153 
5154   // Note that we are loading a type record.
5155   Deserializing AType(this);
5156 
5157   unsigned Idx = 0;
5158   DeclsCursor.JumpToBit(Loc.Offset);
5159   RecordData Record;
5160   unsigned Code = DeclsCursor.ReadCode();
5161   switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5162   case TYPE_EXT_QUAL: {
5163     if (Record.size() != 2) {
5164       Error("Incorrect encoding of extended qualifier type");
5165       return QualType();
5166     }
5167     QualType Base = readType(*Loc.F, Record, Idx);
5168     Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5169     return Context.getQualifiedType(Base, Quals);
5170   }
5171 
5172   case TYPE_COMPLEX: {
5173     if (Record.size() != 1) {
5174       Error("Incorrect encoding of complex type");
5175       return QualType();
5176     }
5177     QualType ElemType = readType(*Loc.F, Record, Idx);
5178     return Context.getComplexType(ElemType);
5179   }
5180 
5181   case TYPE_POINTER: {
5182     if (Record.size() != 1) {
5183       Error("Incorrect encoding of pointer type");
5184       return QualType();
5185     }
5186     QualType PointeeType = readType(*Loc.F, Record, Idx);
5187     return Context.getPointerType(PointeeType);
5188   }
5189 
5190   case TYPE_DECAYED: {
5191     if (Record.size() != 1) {
5192       Error("Incorrect encoding of decayed type");
5193       return QualType();
5194     }
5195     QualType OriginalType = readType(*Loc.F, Record, Idx);
5196     QualType DT = Context.getAdjustedParameterType(OriginalType);
5197     if (!isa<DecayedType>(DT))
5198       Error("Decayed type does not decay");
5199     return DT;
5200   }
5201 
5202   case TYPE_ADJUSTED: {
5203     if (Record.size() != 2) {
5204       Error("Incorrect encoding of adjusted type");
5205       return QualType();
5206     }
5207     QualType OriginalTy = readType(*Loc.F, Record, Idx);
5208     QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5209     return Context.getAdjustedType(OriginalTy, AdjustedTy);
5210   }
5211 
5212   case TYPE_BLOCK_POINTER: {
5213     if (Record.size() != 1) {
5214       Error("Incorrect encoding of block pointer type");
5215       return QualType();
5216     }
5217     QualType PointeeType = readType(*Loc.F, Record, Idx);
5218     return Context.getBlockPointerType(PointeeType);
5219   }
5220 
5221   case TYPE_LVALUE_REFERENCE: {
5222     if (Record.size() != 2) {
5223       Error("Incorrect encoding of lvalue reference type");
5224       return QualType();
5225     }
5226     QualType PointeeType = readType(*Loc.F, Record, Idx);
5227     return Context.getLValueReferenceType(PointeeType, Record[1]);
5228   }
5229 
5230   case TYPE_RVALUE_REFERENCE: {
5231     if (Record.size() != 1) {
5232       Error("Incorrect encoding of rvalue reference type");
5233       return QualType();
5234     }
5235     QualType PointeeType = readType(*Loc.F, Record, Idx);
5236     return Context.getRValueReferenceType(PointeeType);
5237   }
5238 
5239   case TYPE_MEMBER_POINTER: {
5240     if (Record.size() != 2) {
5241       Error("Incorrect encoding of member pointer type");
5242       return QualType();
5243     }
5244     QualType PointeeType = readType(*Loc.F, Record, Idx);
5245     QualType ClassType = readType(*Loc.F, Record, Idx);
5246     if (PointeeType.isNull() || ClassType.isNull())
5247       return QualType();
5248 
5249     return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5250   }
5251 
5252   case TYPE_CONSTANT_ARRAY: {
5253     QualType ElementType = readType(*Loc.F, Record, Idx);
5254     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5255     unsigned IndexTypeQuals = Record[2];
5256     unsigned Idx = 3;
5257     llvm::APInt Size = ReadAPInt(Record, Idx);
5258     return Context.getConstantArrayType(ElementType, Size,
5259                                          ASM, IndexTypeQuals);
5260   }
5261 
5262   case TYPE_INCOMPLETE_ARRAY: {
5263     QualType ElementType = readType(*Loc.F, Record, Idx);
5264     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5265     unsigned IndexTypeQuals = Record[2];
5266     return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5267   }
5268 
5269   case TYPE_VARIABLE_ARRAY: {
5270     QualType ElementType = readType(*Loc.F, Record, Idx);
5271     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5272     unsigned IndexTypeQuals = Record[2];
5273     SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5274     SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5275     return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5276                                          ASM, IndexTypeQuals,
5277                                          SourceRange(LBLoc, RBLoc));
5278   }
5279 
5280   case TYPE_VECTOR: {
5281     if (Record.size() != 3) {
5282       Error("incorrect encoding of vector type in AST file");
5283       return QualType();
5284     }
5285 
5286     QualType ElementType = readType(*Loc.F, Record, Idx);
5287     unsigned NumElements = Record[1];
5288     unsigned VecKind = Record[2];
5289     return Context.getVectorType(ElementType, NumElements,
5290                                   (VectorType::VectorKind)VecKind);
5291   }
5292 
5293   case TYPE_EXT_VECTOR: {
5294     if (Record.size() != 3) {
5295       Error("incorrect encoding of extended vector type in AST file");
5296       return QualType();
5297     }
5298 
5299     QualType ElementType = readType(*Loc.F, Record, Idx);
5300     unsigned NumElements = Record[1];
5301     return Context.getExtVectorType(ElementType, NumElements);
5302   }
5303 
5304   case TYPE_FUNCTION_NO_PROTO: {
5305     if (Record.size() != 6) {
5306       Error("incorrect encoding of no-proto function type");
5307       return QualType();
5308     }
5309     QualType ResultType = readType(*Loc.F, Record, Idx);
5310     FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5311                                (CallingConv)Record[4], Record[5]);
5312     return Context.getFunctionNoProtoType(ResultType, Info);
5313   }
5314 
5315   case TYPE_FUNCTION_PROTO: {
5316     QualType ResultType = readType(*Loc.F, Record, Idx);
5317 
5318     FunctionProtoType::ExtProtoInfo EPI;
5319     EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5320                                         /*hasregparm*/ Record[2],
5321                                         /*regparm*/ Record[3],
5322                                         static_cast<CallingConv>(Record[4]),
5323                                         /*produces*/ Record[5]);
5324 
5325     unsigned Idx = 6;
5326 
5327     EPI.Variadic = Record[Idx++];
5328     EPI.HasTrailingReturn = Record[Idx++];
5329     EPI.TypeQuals = Record[Idx++];
5330     EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5331     SmallVector<QualType, 8> ExceptionStorage;
5332     readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
5333 
5334     unsigned NumParams = Record[Idx++];
5335     SmallVector<QualType, 16> ParamTypes;
5336     for (unsigned I = 0; I != NumParams; ++I)
5337       ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5338 
5339     return Context.getFunctionType(ResultType, ParamTypes, EPI);
5340   }
5341 
5342   case TYPE_UNRESOLVED_USING: {
5343     unsigned Idx = 0;
5344     return Context.getTypeDeclType(
5345                   ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5346   }
5347 
5348   case TYPE_TYPEDEF: {
5349     if (Record.size() != 2) {
5350       Error("incorrect encoding of typedef type");
5351       return QualType();
5352     }
5353     unsigned Idx = 0;
5354     TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5355     QualType Canonical = readType(*Loc.F, Record, Idx);
5356     if (!Canonical.isNull())
5357       Canonical = Context.getCanonicalType(Canonical);
5358     return Context.getTypedefType(Decl, Canonical);
5359   }
5360 
5361   case TYPE_TYPEOF_EXPR:
5362     return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5363 
5364   case TYPE_TYPEOF: {
5365     if (Record.size() != 1) {
5366       Error("incorrect encoding of typeof(type) in AST file");
5367       return QualType();
5368     }
5369     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5370     return Context.getTypeOfType(UnderlyingType);
5371   }
5372 
5373   case TYPE_DECLTYPE: {
5374     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5375     return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5376   }
5377 
5378   case TYPE_UNARY_TRANSFORM: {
5379     QualType BaseType = readType(*Loc.F, Record, Idx);
5380     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5381     UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
5382     return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5383   }
5384 
5385   case TYPE_AUTO: {
5386     QualType Deduced = readType(*Loc.F, Record, Idx);
5387     bool IsDecltypeAuto = Record[Idx++];
5388     bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
5389     return Context.getAutoType(Deduced, IsDecltypeAuto, IsDependent);
5390   }
5391 
5392   case TYPE_RECORD: {
5393     if (Record.size() != 2) {
5394       Error("incorrect encoding of record type");
5395       return QualType();
5396     }
5397     unsigned Idx = 0;
5398     bool IsDependent = Record[Idx++];
5399     RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
5400     RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
5401     QualType T = Context.getRecordType(RD);
5402     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5403     return T;
5404   }
5405 
5406   case TYPE_ENUM: {
5407     if (Record.size() != 2) {
5408       Error("incorrect encoding of enum type");
5409       return QualType();
5410     }
5411     unsigned Idx = 0;
5412     bool IsDependent = Record[Idx++];
5413     QualType T
5414       = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
5415     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5416     return T;
5417   }
5418 
5419   case TYPE_ATTRIBUTED: {
5420     if (Record.size() != 3) {
5421       Error("incorrect encoding of attributed type");
5422       return QualType();
5423     }
5424     QualType modifiedType = readType(*Loc.F, Record, Idx);
5425     QualType equivalentType = readType(*Loc.F, Record, Idx);
5426     AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
5427     return Context.getAttributedType(kind, modifiedType, equivalentType);
5428   }
5429 
5430   case TYPE_PAREN: {
5431     if (Record.size() != 1) {
5432       Error("incorrect encoding of paren type");
5433       return QualType();
5434     }
5435     QualType InnerType = readType(*Loc.F, Record, Idx);
5436     return Context.getParenType(InnerType);
5437   }
5438 
5439   case TYPE_PACK_EXPANSION: {
5440     if (Record.size() != 2) {
5441       Error("incorrect encoding of pack expansion type");
5442       return QualType();
5443     }
5444     QualType Pattern = readType(*Loc.F, Record, Idx);
5445     if (Pattern.isNull())
5446       return QualType();
5447     Optional<unsigned> NumExpansions;
5448     if (Record[1])
5449       NumExpansions = Record[1] - 1;
5450     return Context.getPackExpansionType(Pattern, NumExpansions);
5451   }
5452 
5453   case TYPE_ELABORATED: {
5454     unsigned Idx = 0;
5455     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5456     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5457     QualType NamedType = readType(*Loc.F, Record, Idx);
5458     return Context.getElaboratedType(Keyword, NNS, NamedType);
5459   }
5460 
5461   case TYPE_OBJC_INTERFACE: {
5462     unsigned Idx = 0;
5463     ObjCInterfaceDecl *ItfD
5464       = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
5465     return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
5466   }
5467 
5468   case TYPE_OBJC_OBJECT: {
5469     unsigned Idx = 0;
5470     QualType Base = readType(*Loc.F, Record, Idx);
5471     unsigned NumProtos = Record[Idx++];
5472     SmallVector<ObjCProtocolDecl*, 4> Protos;
5473     for (unsigned I = 0; I != NumProtos; ++I)
5474       Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
5475     return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
5476   }
5477 
5478   case TYPE_OBJC_OBJECT_POINTER: {
5479     unsigned Idx = 0;
5480     QualType Pointee = readType(*Loc.F, Record, Idx);
5481     return Context.getObjCObjectPointerType(Pointee);
5482   }
5483 
5484   case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
5485     unsigned Idx = 0;
5486     QualType Parm = readType(*Loc.F, Record, Idx);
5487     QualType Replacement = readType(*Loc.F, Record, Idx);
5488     return Context.getSubstTemplateTypeParmType(
5489         cast<TemplateTypeParmType>(Parm),
5490         Context.getCanonicalType(Replacement));
5491   }
5492 
5493   case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
5494     unsigned Idx = 0;
5495     QualType Parm = readType(*Loc.F, Record, Idx);
5496     TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
5497     return Context.getSubstTemplateTypeParmPackType(
5498                                                cast<TemplateTypeParmType>(Parm),
5499                                                      ArgPack);
5500   }
5501 
5502   case TYPE_INJECTED_CLASS_NAME: {
5503     CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
5504     QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
5505     // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
5506     // for AST reading, too much interdependencies.
5507     const Type *T = nullptr;
5508     for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
5509       if (const Type *Existing = DI->getTypeForDecl()) {
5510         T = Existing;
5511         break;
5512       }
5513     }
5514     if (!T) {
5515       T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
5516       for (auto *DI = D; DI; DI = DI->getPreviousDecl())
5517         DI->setTypeForDecl(T);
5518     }
5519     return QualType(T, 0);
5520   }
5521 
5522   case TYPE_TEMPLATE_TYPE_PARM: {
5523     unsigned Idx = 0;
5524     unsigned Depth = Record[Idx++];
5525     unsigned Index = Record[Idx++];
5526     bool Pack = Record[Idx++];
5527     TemplateTypeParmDecl *D
5528       = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
5529     return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
5530   }
5531 
5532   case TYPE_DEPENDENT_NAME: {
5533     unsigned Idx = 0;
5534     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5535     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5536     const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
5537     QualType Canon = readType(*Loc.F, Record, Idx);
5538     if (!Canon.isNull())
5539       Canon = Context.getCanonicalType(Canon);
5540     return Context.getDependentNameType(Keyword, NNS, Name, Canon);
5541   }
5542 
5543   case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
5544     unsigned Idx = 0;
5545     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5546     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5547     const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
5548     unsigned NumArgs = Record[Idx++];
5549     SmallVector<TemplateArgument, 8> Args;
5550     Args.reserve(NumArgs);
5551     while (NumArgs--)
5552       Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
5553     return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
5554                                                       Args.size(), Args.data());
5555   }
5556 
5557   case TYPE_DEPENDENT_SIZED_ARRAY: {
5558     unsigned Idx = 0;
5559 
5560     // ArrayType
5561     QualType ElementType = readType(*Loc.F, Record, Idx);
5562     ArrayType::ArraySizeModifier ASM
5563       = (ArrayType::ArraySizeModifier)Record[Idx++];
5564     unsigned IndexTypeQuals = Record[Idx++];
5565 
5566     // DependentSizedArrayType
5567     Expr *NumElts = ReadExpr(*Loc.F);
5568     SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
5569 
5570     return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
5571                                                IndexTypeQuals, Brackets);
5572   }
5573 
5574   case TYPE_TEMPLATE_SPECIALIZATION: {
5575     unsigned Idx = 0;
5576     bool IsDependent = Record[Idx++];
5577     TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
5578     SmallVector<TemplateArgument, 8> Args;
5579     ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
5580     QualType Underlying = readType(*Loc.F, Record, Idx);
5581     QualType T;
5582     if (Underlying.isNull())
5583       T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
5584                                                           Args.size());
5585     else
5586       T = Context.getTemplateSpecializationType(Name, Args.data(),
5587                                                  Args.size(), Underlying);
5588     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5589     return T;
5590   }
5591 
5592   case TYPE_ATOMIC: {
5593     if (Record.size() != 1) {
5594       Error("Incorrect encoding of atomic type");
5595       return QualType();
5596     }
5597     QualType ValueType = readType(*Loc.F, Record, Idx);
5598     return Context.getAtomicType(ValueType);
5599   }
5600   }
5601   llvm_unreachable("Invalid TypeCode!");
5602 }
5603 
5604 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
5605                                   SmallVectorImpl<QualType> &Exceptions,
5606                                   FunctionProtoType::ExceptionSpecInfo &ESI,
5607                                   const RecordData &Record, unsigned &Idx) {
5608   ExceptionSpecificationType EST =
5609       static_cast<ExceptionSpecificationType>(Record[Idx++]);
5610   ESI.Type = EST;
5611   if (EST == EST_Dynamic) {
5612     for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
5613       Exceptions.push_back(readType(ModuleFile, Record, Idx));
5614     ESI.Exceptions = Exceptions;
5615   } else if (EST == EST_ComputedNoexcept) {
5616     ESI.NoexceptExpr = ReadExpr(ModuleFile);
5617   } else if (EST == EST_Uninstantiated) {
5618     ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5619     ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5620   } else if (EST == EST_Unevaluated) {
5621     ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5622   }
5623 }
5624 
5625 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
5626   ASTReader &Reader;
5627   ModuleFile &F;
5628   const ASTReader::RecordData &Record;
5629   unsigned &Idx;
5630 
5631   SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
5632                                     unsigned &I) {
5633     return Reader.ReadSourceLocation(F, R, I);
5634   }
5635 
5636   template<typename T>
5637   T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
5638     return Reader.ReadDeclAs<T>(F, Record, Idx);
5639   }
5640 
5641 public:
5642   TypeLocReader(ASTReader &Reader, ModuleFile &F,
5643                 const ASTReader::RecordData &Record, unsigned &Idx)
5644     : Reader(Reader), F(F), Record(Record), Idx(Idx)
5645   { }
5646 
5647   // We want compile-time assurance that we've enumerated all of
5648   // these, so unfortunately we have to declare them first, then
5649   // define them out-of-line.
5650 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5651 #define TYPELOC(CLASS, PARENT) \
5652   void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
5653 #include "clang/AST/TypeLocNodes.def"
5654 
5655   void VisitFunctionTypeLoc(FunctionTypeLoc);
5656   void VisitArrayTypeLoc(ArrayTypeLoc);
5657 };
5658 
5659 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5660   // nothing to do
5661 }
5662 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5663   TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
5664   if (TL.needsExtraLocalData()) {
5665     TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
5666     TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
5667     TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
5668     TL.setModeAttr(Record[Idx++]);
5669   }
5670 }
5671 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
5672   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5673 }
5674 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
5675   TL.setStarLoc(ReadSourceLocation(Record, Idx));
5676 }
5677 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5678   // nothing to do
5679 }
5680 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5681   // nothing to do
5682 }
5683 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5684   TL.setCaretLoc(ReadSourceLocation(Record, Idx));
5685 }
5686 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5687   TL.setAmpLoc(ReadSourceLocation(Record, Idx));
5688 }
5689 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5690   TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
5691 }
5692 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5693   TL.setStarLoc(ReadSourceLocation(Record, Idx));
5694   TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5695 }
5696 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
5697   TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
5698   TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
5699   if (Record[Idx++])
5700     TL.setSizeExpr(Reader.ReadExpr(F));
5701   else
5702     TL.setSizeExpr(nullptr);
5703 }
5704 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
5705   VisitArrayTypeLoc(TL);
5706 }
5707 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
5708   VisitArrayTypeLoc(TL);
5709 }
5710 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
5711   VisitArrayTypeLoc(TL);
5712 }
5713 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
5714                                             DependentSizedArrayTypeLoc TL) {
5715   VisitArrayTypeLoc(TL);
5716 }
5717 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
5718                                         DependentSizedExtVectorTypeLoc TL) {
5719   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5720 }
5721 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
5722   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5723 }
5724 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
5725   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5726 }
5727 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5728   TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
5729   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5730   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5731   TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
5732   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
5733     TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
5734   }
5735 }
5736 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
5737   VisitFunctionTypeLoc(TL);
5738 }
5739 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
5740   VisitFunctionTypeLoc(TL);
5741 }
5742 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5743   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5744 }
5745 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5746   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5747 }
5748 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5749   TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5750   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5751   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5752 }
5753 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5754   TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5755   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5756   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5757   TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5758 }
5759 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
5760   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5761 }
5762 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5763   TL.setKWLoc(ReadSourceLocation(Record, Idx));
5764   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5765   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5766   TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5767 }
5768 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
5769   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5770 }
5771 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
5772   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5773 }
5774 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
5775   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5776 }
5777 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5778   TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
5779   if (TL.hasAttrOperand()) {
5780     SourceRange range;
5781     range.setBegin(ReadSourceLocation(Record, Idx));
5782     range.setEnd(ReadSourceLocation(Record, Idx));
5783     TL.setAttrOperandParensRange(range);
5784   }
5785   if (TL.hasAttrExprOperand()) {
5786     if (Record[Idx++])
5787       TL.setAttrExprOperand(Reader.ReadExpr(F));
5788     else
5789       TL.setAttrExprOperand(nullptr);
5790   } else if (TL.hasAttrEnumOperand())
5791     TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
5792 }
5793 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
5794   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5795 }
5796 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
5797                                             SubstTemplateTypeParmTypeLoc TL) {
5798   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5799 }
5800 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
5801                                           SubstTemplateTypeParmPackTypeLoc TL) {
5802   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5803 }
5804 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
5805                                            TemplateSpecializationTypeLoc TL) {
5806   TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5807   TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5808   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5809   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5810   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
5811     TL.setArgLocInfo(i,
5812         Reader.GetTemplateArgumentLocInfo(F,
5813                                           TL.getTypePtr()->getArg(i).getKind(),
5814                                           Record, Idx));
5815 }
5816 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
5817   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5818   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5819 }
5820 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5821   TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5822   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5823 }
5824 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
5825   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5826 }
5827 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5828   TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5829   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5830   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5831 }
5832 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
5833        DependentTemplateSpecializationTypeLoc TL) {
5834   TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5835   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5836   TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5837   TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5838   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5839   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5840   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
5841     TL.setArgLocInfo(I,
5842         Reader.GetTemplateArgumentLocInfo(F,
5843                                           TL.getTypePtr()->getArg(I).getKind(),
5844                                           Record, Idx));
5845 }
5846 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
5847   TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
5848 }
5849 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5850   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5851 }
5852 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5853   TL.setHasBaseTypeAsWritten(Record[Idx++]);
5854   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5855   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5856   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
5857     TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
5858 }
5859 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5860   TL.setStarLoc(ReadSourceLocation(Record, Idx));
5861 }
5862 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5863   TL.setKWLoc(ReadSourceLocation(Record, Idx));
5864   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5865   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5866 }
5867 
5868 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
5869                                              const RecordData &Record,
5870                                              unsigned &Idx) {
5871   QualType InfoTy = readType(F, Record, Idx);
5872   if (InfoTy.isNull())
5873     return nullptr;
5874 
5875   TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
5876   TypeLocReader TLR(*this, F, Record, Idx);
5877   for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
5878     TLR.Visit(TL);
5879   return TInfo;
5880 }
5881 
5882 QualType ASTReader::GetType(TypeID ID) {
5883   unsigned FastQuals = ID & Qualifiers::FastMask;
5884   unsigned Index = ID >> Qualifiers::FastWidth;
5885 
5886   if (Index < NUM_PREDEF_TYPE_IDS) {
5887     QualType T;
5888     switch ((PredefinedTypeIDs)Index) {
5889     case PREDEF_TYPE_NULL_ID: return QualType();
5890     case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
5891     case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
5892 
5893     case PREDEF_TYPE_CHAR_U_ID:
5894     case PREDEF_TYPE_CHAR_S_ID:
5895       // FIXME: Check that the signedness of CharTy is correct!
5896       T = Context.CharTy;
5897       break;
5898 
5899     case PREDEF_TYPE_UCHAR_ID:      T = Context.UnsignedCharTy;     break;
5900     case PREDEF_TYPE_USHORT_ID:     T = Context.UnsignedShortTy;    break;
5901     case PREDEF_TYPE_UINT_ID:       T = Context.UnsignedIntTy;      break;
5902     case PREDEF_TYPE_ULONG_ID:      T = Context.UnsignedLongTy;     break;
5903     case PREDEF_TYPE_ULONGLONG_ID:  T = Context.UnsignedLongLongTy; break;
5904     case PREDEF_TYPE_UINT128_ID:    T = Context.UnsignedInt128Ty;   break;
5905     case PREDEF_TYPE_SCHAR_ID:      T = Context.SignedCharTy;       break;
5906     case PREDEF_TYPE_WCHAR_ID:      T = Context.WCharTy;            break;
5907     case PREDEF_TYPE_SHORT_ID:      T = Context.ShortTy;            break;
5908     case PREDEF_TYPE_INT_ID:        T = Context.IntTy;              break;
5909     case PREDEF_TYPE_LONG_ID:       T = Context.LongTy;             break;
5910     case PREDEF_TYPE_LONGLONG_ID:   T = Context.LongLongTy;         break;
5911     case PREDEF_TYPE_INT128_ID:     T = Context.Int128Ty;           break;
5912     case PREDEF_TYPE_HALF_ID:       T = Context.HalfTy;             break;
5913     case PREDEF_TYPE_FLOAT_ID:      T = Context.FloatTy;            break;
5914     case PREDEF_TYPE_DOUBLE_ID:     T = Context.DoubleTy;           break;
5915     case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy;       break;
5916     case PREDEF_TYPE_OVERLOAD_ID:   T = Context.OverloadTy;         break;
5917     case PREDEF_TYPE_BOUND_MEMBER:  T = Context.BoundMemberTy;      break;
5918     case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy;     break;
5919     case PREDEF_TYPE_DEPENDENT_ID:  T = Context.DependentTy;        break;
5920     case PREDEF_TYPE_UNKNOWN_ANY:   T = Context.UnknownAnyTy;       break;
5921     case PREDEF_TYPE_NULLPTR_ID:    T = Context.NullPtrTy;          break;
5922     case PREDEF_TYPE_CHAR16_ID:     T = Context.Char16Ty;           break;
5923     case PREDEF_TYPE_CHAR32_ID:     T = Context.Char32Ty;           break;
5924     case PREDEF_TYPE_OBJC_ID:       T = Context.ObjCBuiltinIdTy;    break;
5925     case PREDEF_TYPE_OBJC_CLASS:    T = Context.ObjCBuiltinClassTy; break;
5926     case PREDEF_TYPE_OBJC_SEL:      T = Context.ObjCBuiltinSelTy;   break;
5927     case PREDEF_TYPE_IMAGE1D_ID:    T = Context.OCLImage1dTy;       break;
5928     case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break;
5929     case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break;
5930     case PREDEF_TYPE_IMAGE2D_ID:    T = Context.OCLImage2dTy;       break;
5931     case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break;
5932     case PREDEF_TYPE_IMAGE3D_ID:    T = Context.OCLImage3dTy;       break;
5933     case PREDEF_TYPE_SAMPLER_ID:    T = Context.OCLSamplerTy;       break;
5934     case PREDEF_TYPE_EVENT_ID:      T = Context.OCLEventTy;         break;
5935     case PREDEF_TYPE_AUTO_DEDUCT:   T = Context.getAutoDeductType(); break;
5936 
5937     case PREDEF_TYPE_AUTO_RREF_DEDUCT:
5938       T = Context.getAutoRRefDeductType();
5939       break;
5940 
5941     case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
5942       T = Context.ARCUnbridgedCastTy;
5943       break;
5944 
5945     case PREDEF_TYPE_VA_LIST_TAG:
5946       T = Context.getVaListTagType();
5947       break;
5948 
5949     case PREDEF_TYPE_BUILTIN_FN:
5950       T = Context.BuiltinFnTy;
5951       break;
5952     }
5953 
5954     assert(!T.isNull() && "Unknown predefined type");
5955     return T.withFastQualifiers(FastQuals);
5956   }
5957 
5958   Index -= NUM_PREDEF_TYPE_IDS;
5959   assert(Index < TypesLoaded.size() && "Type index out-of-range");
5960   if (TypesLoaded[Index].isNull()) {
5961     TypesLoaded[Index] = readTypeRecord(Index);
5962     if (TypesLoaded[Index].isNull())
5963       return QualType();
5964 
5965     TypesLoaded[Index]->setFromAST();
5966     if (DeserializationListener)
5967       DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
5968                                         TypesLoaded[Index]);
5969   }
5970 
5971   return TypesLoaded[Index].withFastQualifiers(FastQuals);
5972 }
5973 
5974 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
5975   return GetType(getGlobalTypeID(F, LocalID));
5976 }
5977 
5978 serialization::TypeID
5979 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
5980   unsigned FastQuals = LocalID & Qualifiers::FastMask;
5981   unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
5982 
5983   if (LocalIndex < NUM_PREDEF_TYPE_IDS)
5984     return LocalID;
5985 
5986   ContinuousRangeMap<uint32_t, int, 2>::iterator I
5987     = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
5988   assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
5989 
5990   unsigned GlobalIndex = LocalIndex + I->second;
5991   return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
5992 }
5993 
5994 TemplateArgumentLocInfo
5995 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
5996                                       TemplateArgument::ArgKind Kind,
5997                                       const RecordData &Record,
5998                                       unsigned &Index) {
5999   switch (Kind) {
6000   case TemplateArgument::Expression:
6001     return ReadExpr(F);
6002   case TemplateArgument::Type:
6003     return GetTypeSourceInfo(F, Record, Index);
6004   case TemplateArgument::Template: {
6005     NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6006                                                                      Index);
6007     SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6008     return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6009                                    SourceLocation());
6010   }
6011   case TemplateArgument::TemplateExpansion: {
6012     NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6013                                                                      Index);
6014     SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6015     SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6016     return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6017                                    EllipsisLoc);
6018   }
6019   case TemplateArgument::Null:
6020   case TemplateArgument::Integral:
6021   case TemplateArgument::Declaration:
6022   case TemplateArgument::NullPtr:
6023   case TemplateArgument::Pack:
6024     // FIXME: Is this right?
6025     return TemplateArgumentLocInfo();
6026   }
6027   llvm_unreachable("unexpected template argument loc");
6028 }
6029 
6030 TemplateArgumentLoc
6031 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
6032                                    const RecordData &Record, unsigned &Index) {
6033   TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6034 
6035   if (Arg.getKind() == TemplateArgument::Expression) {
6036     if (Record[Index++]) // bool InfoHasSameExpr.
6037       return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
6038   }
6039   return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6040                                                              Record, Index));
6041 }
6042 
6043 const ASTTemplateArgumentListInfo*
6044 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
6045                                            const RecordData &Record,
6046                                            unsigned &Index) {
6047   SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6048   SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6049   unsigned NumArgsAsWritten = Record[Index++];
6050   TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6051   for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6052     TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6053   return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6054 }
6055 
6056 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6057   return GetDecl(ID);
6058 }
6059 
6060 void ASTReader::CompleteRedeclChain(const Decl *D) {
6061   if (NumCurrentElementsDeserializing) {
6062     // We arrange to not care about the complete redeclaration chain while we're
6063     // deserializing. Just remember that the AST has marked this one as complete
6064     // but that it's not actually complete yet, so we know we still need to
6065     // complete it later.
6066     PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6067     return;
6068   }
6069 
6070   const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6071 
6072   // If this is a named declaration, complete it by looking it up
6073   // within its context.
6074   //
6075   // FIXME: Merging a function definition should merge
6076   // all mergeable entities within it.
6077   if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6078       isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6079     if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6080       auto *II = Name.getAsIdentifierInfo();
6081       if (isa<TranslationUnitDecl>(DC) && II) {
6082         // Outside of C++, we don't have a lookup table for the TU, so update
6083         // the identifier instead. In C++, either way should work fine.
6084         if (II->isOutOfDate())
6085           updateOutOfDateIdentifier(*II);
6086       } else
6087         DC->lookup(Name);
6088     } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
6089       // FIXME: It'd be nice to do something a bit more targeted here.
6090       D->getDeclContext()->decls_begin();
6091     }
6092   }
6093 }
6094 
6095 uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M,
6096                                           const RecordData &Record,
6097                                           unsigned &Idx) {
6098   if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXBaseSpecifiers) {
6099     Error("malformed AST file: missing C++ base specifier");
6100     return 0;
6101   }
6102 
6103   unsigned LocalID = Record[Idx++];
6104   return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
6105 }
6106 
6107 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
6108   RecordLocation Loc = getLocalBitOffset(Offset);
6109   BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6110   SavedStreamPosition SavedPosition(Cursor);
6111   Cursor.JumpToBit(Loc.Offset);
6112   ReadingKindTracker ReadingKind(Read_Decl, *this);
6113   RecordData Record;
6114   unsigned Code = Cursor.ReadCode();
6115   unsigned RecCode = Cursor.readRecord(Code, Record);
6116   if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
6117     Error("malformed AST file: missing C++ base specifiers");
6118     return nullptr;
6119   }
6120 
6121   unsigned Idx = 0;
6122   unsigned NumBases = Record[Idx++];
6123   void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
6124   CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
6125   for (unsigned I = 0; I != NumBases; ++I)
6126     Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
6127   return Bases;
6128 }
6129 
6130 serialization::DeclID
6131 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
6132   if (LocalID < NUM_PREDEF_DECL_IDS)
6133     return LocalID;
6134 
6135   ContinuousRangeMap<uint32_t, int, 2>::iterator I
6136     = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
6137   assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
6138 
6139   return LocalID + I->second;
6140 }
6141 
6142 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
6143                                    ModuleFile &M) const {
6144   GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID);
6145   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6146   return &M == I->second;
6147 }
6148 
6149 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
6150   if (!D->isFromASTFile())
6151     return nullptr;
6152   GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
6153   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6154   return I->second;
6155 }
6156 
6157 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
6158   if (ID < NUM_PREDEF_DECL_IDS)
6159     return SourceLocation();
6160 
6161   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6162 
6163   if (Index > DeclsLoaded.size()) {
6164     Error("declaration ID out-of-range for AST file");
6165     return SourceLocation();
6166   }
6167 
6168   if (Decl *D = DeclsLoaded[Index])
6169     return D->getLocation();
6170 
6171   unsigned RawLocation = 0;
6172   RecordLocation Rec = DeclCursorForID(ID, RawLocation);
6173   return ReadSourceLocation(*Rec.F, RawLocation);
6174 }
6175 
6176 Decl *ASTReader::GetExistingDecl(DeclID ID) {
6177   if (ID < NUM_PREDEF_DECL_IDS) {
6178     switch ((PredefinedDeclIDs)ID) {
6179     case PREDEF_DECL_NULL_ID:
6180       return nullptr;
6181 
6182     case PREDEF_DECL_TRANSLATION_UNIT_ID:
6183       return Context.getTranslationUnitDecl();
6184 
6185     case PREDEF_DECL_OBJC_ID_ID:
6186       return Context.getObjCIdDecl();
6187 
6188     case PREDEF_DECL_OBJC_SEL_ID:
6189       return Context.getObjCSelDecl();
6190 
6191     case PREDEF_DECL_OBJC_CLASS_ID:
6192       return Context.getObjCClassDecl();
6193 
6194     case PREDEF_DECL_OBJC_PROTOCOL_ID:
6195       return Context.getObjCProtocolDecl();
6196 
6197     case PREDEF_DECL_INT_128_ID:
6198       return Context.getInt128Decl();
6199 
6200     case PREDEF_DECL_UNSIGNED_INT_128_ID:
6201       return Context.getUInt128Decl();
6202 
6203     case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
6204       return Context.getObjCInstanceTypeDecl();
6205 
6206     case PREDEF_DECL_BUILTIN_VA_LIST_ID:
6207       return Context.getBuiltinVaListDecl();
6208     }
6209   }
6210 
6211   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6212 
6213   if (Index >= DeclsLoaded.size()) {
6214     assert(0 && "declaration ID out-of-range for AST file");
6215     Error("declaration ID out-of-range for AST file");
6216     return nullptr;
6217   }
6218 
6219   return DeclsLoaded[Index];
6220 }
6221 
6222 Decl *ASTReader::GetDecl(DeclID ID) {
6223   if (ID < NUM_PREDEF_DECL_IDS)
6224     return GetExistingDecl(ID);
6225 
6226   unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6227 
6228   if (Index >= DeclsLoaded.size()) {
6229     assert(0 && "declaration ID out-of-range for AST file");
6230     Error("declaration ID out-of-range for AST file");
6231     return nullptr;
6232   }
6233 
6234   if (!DeclsLoaded[Index]) {
6235     ReadDeclRecord(ID);
6236     if (DeserializationListener)
6237       DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
6238   }
6239 
6240   return DeclsLoaded[Index];
6241 }
6242 
6243 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
6244                                                   DeclID GlobalID) {
6245   if (GlobalID < NUM_PREDEF_DECL_IDS)
6246     return GlobalID;
6247 
6248   GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
6249   assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6250   ModuleFile *Owner = I->second;
6251 
6252   llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
6253     = M.GlobalToLocalDeclIDs.find(Owner);
6254   if (Pos == M.GlobalToLocalDeclIDs.end())
6255     return 0;
6256 
6257   return GlobalID - Owner->BaseDeclID + Pos->second;
6258 }
6259 
6260 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
6261                                             const RecordData &Record,
6262                                             unsigned &Idx) {
6263   if (Idx >= Record.size()) {
6264     Error("Corrupted AST file");
6265     return 0;
6266   }
6267 
6268   return getGlobalDeclID(F, Record[Idx++]);
6269 }
6270 
6271 /// \brief Resolve the offset of a statement into a statement.
6272 ///
6273 /// This operation will read a new statement from the external
6274 /// source each time it is called, and is meant to be used via a
6275 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
6276 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
6277   // Switch case IDs are per Decl.
6278   ClearSwitchCaseIDs();
6279 
6280   // Offset here is a global offset across the entire chain.
6281   RecordLocation Loc = getLocalBitOffset(Offset);
6282   Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
6283   return ReadStmtFromStream(*Loc.F);
6284 }
6285 
6286 namespace {
6287   class FindExternalLexicalDeclsVisitor {
6288     ASTReader &Reader;
6289     const DeclContext *DC;
6290     bool (*isKindWeWant)(Decl::Kind);
6291 
6292     SmallVectorImpl<Decl*> &Decls;
6293     bool PredefsVisited[NUM_PREDEF_DECL_IDS];
6294 
6295   public:
6296     FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
6297                                     bool (*isKindWeWant)(Decl::Kind),
6298                                     SmallVectorImpl<Decl*> &Decls)
6299       : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
6300     {
6301       for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
6302         PredefsVisited[I] = false;
6303     }
6304 
6305     static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
6306       if (Preorder)
6307         return false;
6308 
6309       FindExternalLexicalDeclsVisitor *This
6310         = static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
6311 
6312       ModuleFile::DeclContextInfosMap::iterator Info
6313         = M.DeclContextInfos.find(This->DC);
6314       if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
6315         return false;
6316 
6317       // Load all of the declaration IDs
6318       for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
6319                                *IDE = ID + Info->second.NumLexicalDecls;
6320            ID != IDE; ++ID) {
6321         if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
6322           continue;
6323 
6324         // Don't add predefined declarations to the lexical context more
6325         // than once.
6326         if (ID->second < NUM_PREDEF_DECL_IDS) {
6327           if (This->PredefsVisited[ID->second])
6328             continue;
6329 
6330           This->PredefsVisited[ID->second] = true;
6331         }
6332 
6333         if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
6334           if (!This->DC->isDeclInLexicalTraversal(D))
6335             This->Decls.push_back(D);
6336         }
6337       }
6338 
6339       return false;
6340     }
6341   };
6342 }
6343 
6344 ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
6345                                          bool (*isKindWeWant)(Decl::Kind),
6346                                          SmallVectorImpl<Decl*> &Decls) {
6347   // There might be lexical decls in multiple modules, for the TU at
6348   // least. Walk all of the modules in the order they were loaded.
6349   FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
6350   ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor);
6351   ++NumLexicalDeclContextsRead;
6352   return ELR_Success;
6353 }
6354 
6355 namespace {
6356 
6357 class DeclIDComp {
6358   ASTReader &Reader;
6359   ModuleFile &Mod;
6360 
6361 public:
6362   DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
6363 
6364   bool operator()(LocalDeclID L, LocalDeclID R) const {
6365     SourceLocation LHS = getLocation(L);
6366     SourceLocation RHS = getLocation(R);
6367     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6368   }
6369 
6370   bool operator()(SourceLocation LHS, LocalDeclID R) const {
6371     SourceLocation RHS = getLocation(R);
6372     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6373   }
6374 
6375   bool operator()(LocalDeclID L, SourceLocation RHS) const {
6376     SourceLocation LHS = getLocation(L);
6377     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6378   }
6379 
6380   SourceLocation getLocation(LocalDeclID ID) const {
6381     return Reader.getSourceManager().getFileLoc(
6382             Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
6383   }
6384 };
6385 
6386 }
6387 
6388 void ASTReader::FindFileRegionDecls(FileID File,
6389                                     unsigned Offset, unsigned Length,
6390                                     SmallVectorImpl<Decl *> &Decls) {
6391   SourceManager &SM = getSourceManager();
6392 
6393   llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
6394   if (I == FileDeclIDs.end())
6395     return;
6396 
6397   FileDeclsInfo &DInfo = I->second;
6398   if (DInfo.Decls.empty())
6399     return;
6400 
6401   SourceLocation
6402     BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
6403   SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
6404 
6405   DeclIDComp DIDComp(*this, *DInfo.Mod);
6406   ArrayRef<serialization::LocalDeclID>::iterator
6407     BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6408                                BeginLoc, DIDComp);
6409   if (BeginIt != DInfo.Decls.begin())
6410     --BeginIt;
6411 
6412   // If we are pointing at a top-level decl inside an objc container, we need
6413   // to backtrack until we find it otherwise we will fail to report that the
6414   // region overlaps with an objc container.
6415   while (BeginIt != DInfo.Decls.begin() &&
6416          GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
6417              ->isTopLevelDeclInObjCContainer())
6418     --BeginIt;
6419 
6420   ArrayRef<serialization::LocalDeclID>::iterator
6421     EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6422                              EndLoc, DIDComp);
6423   if (EndIt != DInfo.Decls.end())
6424     ++EndIt;
6425 
6426   for (ArrayRef<serialization::LocalDeclID>::iterator
6427          DIt = BeginIt; DIt != EndIt; ++DIt)
6428     Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
6429 }
6430 
6431 namespace {
6432   /// \brief ModuleFile visitor used to perform name lookup into a
6433   /// declaration context.
6434   class DeclContextNameLookupVisitor {
6435     ASTReader &Reader;
6436     ArrayRef<const DeclContext *> Contexts;
6437     DeclarationName Name;
6438     SmallVectorImpl<NamedDecl *> &Decls;
6439 
6440   public:
6441     DeclContextNameLookupVisitor(ASTReader &Reader,
6442                                  ArrayRef<const DeclContext *> Contexts,
6443                                  DeclarationName Name,
6444                                  SmallVectorImpl<NamedDecl *> &Decls)
6445       : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { }
6446 
6447     static bool visit(ModuleFile &M, void *UserData) {
6448       DeclContextNameLookupVisitor *This
6449         = static_cast<DeclContextNameLookupVisitor *>(UserData);
6450 
6451       // Check whether we have any visible declaration information for
6452       // this context in this module.
6453       ModuleFile::DeclContextInfosMap::iterator Info;
6454       bool FoundInfo = false;
6455       for (auto *DC : This->Contexts) {
6456         Info = M.DeclContextInfos.find(DC);
6457         if (Info != M.DeclContextInfos.end() &&
6458             Info->second.NameLookupTableData) {
6459           FoundInfo = true;
6460           break;
6461         }
6462       }
6463 
6464       if (!FoundInfo)
6465         return false;
6466 
6467       // Look for this name within this module.
6468       ASTDeclContextNameLookupTable *LookupTable =
6469         Info->second.NameLookupTableData;
6470       ASTDeclContextNameLookupTable::iterator Pos
6471         = LookupTable->find(This->Name);
6472       if (Pos == LookupTable->end())
6473         return false;
6474 
6475       bool FoundAnything = false;
6476       ASTDeclContextNameLookupTrait::data_type Data = *Pos;
6477       for (; Data.first != Data.second; ++Data.first) {
6478         NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
6479         if (!ND)
6480           continue;
6481 
6482         if (ND->getDeclName() != This->Name) {
6483           // A name might be null because the decl's redeclarable part is
6484           // currently read before reading its name. The lookup is triggered by
6485           // building that decl (likely indirectly), and so it is later in the
6486           // sense of "already existing" and can be ignored here.
6487           // FIXME: This should not happen; deserializing declarations should
6488           // not perform lookups since that can lead to deserialization cycles.
6489           continue;
6490         }
6491 
6492         // Record this declaration.
6493         FoundAnything = true;
6494         This->Decls.push_back(ND);
6495       }
6496 
6497       return FoundAnything;
6498     }
6499   };
6500 }
6501 
6502 /// \brief Retrieve the "definitive" module file for the definition of the
6503 /// given declaration context, if there is one.
6504 ///
6505 /// The "definitive" module file is the only place where we need to look to
6506 /// find information about the declarations within the given declaration
6507 /// context. For example, C++ and Objective-C classes, C structs/unions, and
6508 /// Objective-C protocols, categories, and extensions are all defined in a
6509 /// single place in the source code, so they have definitive module files
6510 /// associated with them. C++ namespaces, on the other hand, can have
6511 /// definitions in multiple different module files.
6512 ///
6513 /// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's
6514 /// NDEBUG checking.
6515 static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC,
6516                                               ASTReader &Reader) {
6517   if (const DeclContext *DefDC = getDefinitiveDeclContext(DC))
6518     return Reader.getOwningModuleFile(cast<Decl>(DefDC));
6519 
6520   return nullptr;
6521 }
6522 
6523 bool
6524 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
6525                                           DeclarationName Name) {
6526   assert(DC->hasExternalVisibleStorage() &&
6527          "DeclContext has no visible decls in storage");
6528   if (!Name)
6529     return false;
6530 
6531   Deserializing LookupResults(this);
6532 
6533   SmallVector<NamedDecl *, 64> Decls;
6534 
6535   // Compute the declaration contexts we need to look into. Multiple such
6536   // declaration contexts occur when two declaration contexts from disjoint
6537   // modules get merged, e.g., when two namespaces with the same name are
6538   // independently defined in separate modules.
6539   SmallVector<const DeclContext *, 2> Contexts;
6540   Contexts.push_back(DC);
6541 
6542   if (DC->isNamespace()) {
6543     auto Merged = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
6544     if (Merged != MergedDecls.end()) {
6545       for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
6546         Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
6547     }
6548   }
6549 
6550   auto LookUpInContexts = [&](ArrayRef<const DeclContext*> Contexts) {
6551     DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls);
6552 
6553     // If we can definitively determine which module file to look into,
6554     // only look there. Otherwise, look in all module files.
6555     ModuleFile *Definitive;
6556     if (Contexts.size() == 1 &&
6557         (Definitive = getDefinitiveModuleFileFor(Contexts[0], *this))) {
6558       DeclContextNameLookupVisitor::visit(*Definitive, &Visitor);
6559     } else {
6560       ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
6561     }
6562   };
6563 
6564   LookUpInContexts(Contexts);
6565 
6566   // If this might be an implicit special member function, then also search
6567   // all merged definitions of the surrounding class. We need to search them
6568   // individually, because finding an entity in one of them doesn't imply that
6569   // we can't find a different entity in another one.
6570   if (isa<CXXRecordDecl>(DC)) {
6571     auto Kind = Name.getNameKind();
6572     if (Kind == DeclarationName::CXXConstructorName ||
6573         Kind == DeclarationName::CXXDestructorName ||
6574         (Kind == DeclarationName::CXXOperatorName &&
6575          Name.getCXXOverloadedOperator() == OO_Equal)) {
6576       auto Merged = MergedLookups.find(DC);
6577       if (Merged != MergedLookups.end())
6578         for (auto *MergedDC : Merged->second)
6579           LookUpInContexts(MergedDC);
6580     }
6581   }
6582 
6583   ++NumVisibleDeclContextsRead;
6584   SetExternalVisibleDeclsForName(DC, Name, Decls);
6585   return !Decls.empty();
6586 }
6587 
6588 namespace {
6589   /// \brief ModuleFile visitor used to retrieve all visible names in a
6590   /// declaration context.
6591   class DeclContextAllNamesVisitor {
6592     ASTReader &Reader;
6593     SmallVectorImpl<const DeclContext *> &Contexts;
6594     DeclsMap &Decls;
6595     bool VisitAll;
6596 
6597   public:
6598     DeclContextAllNamesVisitor(ASTReader &Reader,
6599                                SmallVectorImpl<const DeclContext *> &Contexts,
6600                                DeclsMap &Decls, bool VisitAll)
6601       : Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { }
6602 
6603     static bool visit(ModuleFile &M, void *UserData) {
6604       DeclContextAllNamesVisitor *This
6605         = static_cast<DeclContextAllNamesVisitor *>(UserData);
6606 
6607       // Check whether we have any visible declaration information for
6608       // this context in this module.
6609       ModuleFile::DeclContextInfosMap::iterator Info;
6610       bool FoundInfo = false;
6611       for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
6612         Info = M.DeclContextInfos.find(This->Contexts[I]);
6613         if (Info != M.DeclContextInfos.end() &&
6614             Info->second.NameLookupTableData) {
6615           FoundInfo = true;
6616           break;
6617         }
6618       }
6619 
6620       if (!FoundInfo)
6621         return false;
6622 
6623       ASTDeclContextNameLookupTable *LookupTable =
6624         Info->second.NameLookupTableData;
6625       bool FoundAnything = false;
6626       for (ASTDeclContextNameLookupTable::data_iterator
6627              I = LookupTable->data_begin(), E = LookupTable->data_end();
6628            I != E;
6629            ++I) {
6630         ASTDeclContextNameLookupTrait::data_type Data = *I;
6631         for (; Data.first != Data.second; ++Data.first) {
6632           NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M,
6633                                                                  *Data.first);
6634           if (!ND)
6635             continue;
6636 
6637           // Record this declaration.
6638           FoundAnything = true;
6639           This->Decls[ND->getDeclName()].push_back(ND);
6640         }
6641       }
6642 
6643       return FoundAnything && !This->VisitAll;
6644     }
6645   };
6646 }
6647 
6648 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
6649   if (!DC->hasExternalVisibleStorage())
6650     return;
6651   DeclsMap Decls;
6652 
6653   // Compute the declaration contexts we need to look into. Multiple such
6654   // declaration contexts occur when two declaration contexts from disjoint
6655   // modules get merged, e.g., when two namespaces with the same name are
6656   // independently defined in separate modules.
6657   SmallVector<const DeclContext *, 2> Contexts;
6658   Contexts.push_back(DC);
6659 
6660   if (DC->isNamespace()) {
6661     MergedDeclsMap::iterator Merged
6662       = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
6663     if (Merged != MergedDecls.end()) {
6664       for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
6665         Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
6666     }
6667   }
6668 
6669   DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls,
6670                                      /*VisitAll=*/DC->isFileContext());
6671   ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor);
6672   ++NumVisibleDeclContextsRead;
6673 
6674   for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
6675     SetExternalVisibleDeclsForName(DC, I->first, I->second);
6676   }
6677   const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
6678 }
6679 
6680 /// \brief Under non-PCH compilation the consumer receives the objc methods
6681 /// before receiving the implementation, and codegen depends on this.
6682 /// We simulate this by deserializing and passing to consumer the methods of the
6683 /// implementation before passing the deserialized implementation decl.
6684 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
6685                                        ASTConsumer *Consumer) {
6686   assert(ImplD && Consumer);
6687 
6688   for (auto *I : ImplD->methods())
6689     Consumer->HandleInterestingDecl(DeclGroupRef(I));
6690 
6691   Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
6692 }
6693 
6694 void ASTReader::PassInterestingDeclsToConsumer() {
6695   assert(Consumer);
6696 
6697   if (PassingDeclsToConsumer)
6698     return;
6699 
6700   // Guard variable to avoid recursively redoing the process of passing
6701   // decls to consumer.
6702   SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
6703                                                    true);
6704 
6705   while (!InterestingDecls.empty()) {
6706     Decl *D = InterestingDecls.front();
6707     InterestingDecls.pop_front();
6708 
6709     PassInterestingDeclToConsumer(D);
6710   }
6711 }
6712 
6713 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
6714   if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
6715     PassObjCImplDeclToConsumer(ImplD, Consumer);
6716   else
6717     Consumer->HandleInterestingDecl(DeclGroupRef(D));
6718 }
6719 
6720 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
6721   this->Consumer = Consumer;
6722 
6723   if (!Consumer)
6724     return;
6725 
6726   for (unsigned I = 0, N = EagerlyDeserializedDecls.size(); I != N; ++I) {
6727     // Force deserialization of this decl, which will cause it to be queued for
6728     // passing to the consumer.
6729     GetDecl(EagerlyDeserializedDecls[I]);
6730   }
6731   EagerlyDeserializedDecls.clear();
6732 
6733   PassInterestingDeclsToConsumer();
6734 }
6735 
6736 void ASTReader::PrintStats() {
6737   std::fprintf(stderr, "*** AST File Statistics:\n");
6738 
6739   unsigned NumTypesLoaded
6740     = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
6741                                       QualType());
6742   unsigned NumDeclsLoaded
6743     = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
6744                                       (Decl *)nullptr);
6745   unsigned NumIdentifiersLoaded
6746     = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
6747                                             IdentifiersLoaded.end(),
6748                                             (IdentifierInfo *)nullptr);
6749   unsigned NumMacrosLoaded
6750     = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
6751                                        MacrosLoaded.end(),
6752                                        (MacroInfo *)nullptr);
6753   unsigned NumSelectorsLoaded
6754     = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
6755                                           SelectorsLoaded.end(),
6756                                           Selector());
6757 
6758   if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
6759     std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
6760                  NumSLocEntriesRead, TotalNumSLocEntries,
6761                  ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
6762   if (!TypesLoaded.empty())
6763     std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
6764                  NumTypesLoaded, (unsigned)TypesLoaded.size(),
6765                  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
6766   if (!DeclsLoaded.empty())
6767     std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
6768                  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
6769                  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
6770   if (!IdentifiersLoaded.empty())
6771     std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
6772                  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
6773                  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
6774   if (!MacrosLoaded.empty())
6775     std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
6776                  NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
6777                  ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
6778   if (!SelectorsLoaded.empty())
6779     std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
6780                  NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
6781                  ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
6782   if (TotalNumStatements)
6783     std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
6784                  NumStatementsRead, TotalNumStatements,
6785                  ((float)NumStatementsRead/TotalNumStatements * 100));
6786   if (TotalNumMacros)
6787     std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
6788                  NumMacrosRead, TotalNumMacros,
6789                  ((float)NumMacrosRead/TotalNumMacros * 100));
6790   if (TotalLexicalDeclContexts)
6791     std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
6792                  NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
6793                  ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
6794                   * 100));
6795   if (TotalVisibleDeclContexts)
6796     std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
6797                  NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
6798                  ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
6799                   * 100));
6800   if (TotalNumMethodPoolEntries) {
6801     std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
6802                  NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
6803                  ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
6804                   * 100));
6805   }
6806   if (NumMethodPoolLookups) {
6807     std::fprintf(stderr, "  %u/%u method pool lookups succeeded (%f%%)\n",
6808                  NumMethodPoolHits, NumMethodPoolLookups,
6809                  ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
6810   }
6811   if (NumMethodPoolTableLookups) {
6812     std::fprintf(stderr, "  %u/%u method pool table lookups succeeded (%f%%)\n",
6813                  NumMethodPoolTableHits, NumMethodPoolTableLookups,
6814                  ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
6815                   * 100.0));
6816   }
6817 
6818   if (NumIdentifierLookupHits) {
6819     std::fprintf(stderr,
6820                  "  %u / %u identifier table lookups succeeded (%f%%)\n",
6821                  NumIdentifierLookupHits, NumIdentifierLookups,
6822                  (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
6823   }
6824 
6825   if (GlobalIndex) {
6826     std::fprintf(stderr, "\n");
6827     GlobalIndex->printStats();
6828   }
6829 
6830   std::fprintf(stderr, "\n");
6831   dump();
6832   std::fprintf(stderr, "\n");
6833 }
6834 
6835 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
6836 static void
6837 dumpModuleIDMap(StringRef Name,
6838                 const ContinuousRangeMap<Key, ModuleFile *,
6839                                          InitialCapacity> &Map) {
6840   if (Map.begin() == Map.end())
6841     return;
6842 
6843   typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
6844   llvm::errs() << Name << ":\n";
6845   for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
6846        I != IEnd; ++I) {
6847     llvm::errs() << "  " << I->first << " -> " << I->second->FileName
6848       << "\n";
6849   }
6850 }
6851 
6852 void ASTReader::dump() {
6853   llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
6854   dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
6855   dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
6856   dumpModuleIDMap("Global type map", GlobalTypeMap);
6857   dumpModuleIDMap("Global declaration map", GlobalDeclMap);
6858   dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
6859   dumpModuleIDMap("Global macro map", GlobalMacroMap);
6860   dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
6861   dumpModuleIDMap("Global selector map", GlobalSelectorMap);
6862   dumpModuleIDMap("Global preprocessed entity map",
6863                   GlobalPreprocessedEntityMap);
6864 
6865   llvm::errs() << "\n*** PCH/Modules Loaded:";
6866   for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
6867                                        MEnd = ModuleMgr.end();
6868        M != MEnd; ++M)
6869     (*M)->dump();
6870 }
6871 
6872 /// Return the amount of memory used by memory buffers, breaking down
6873 /// by heap-backed versus mmap'ed memory.
6874 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
6875   for (ModuleConstIterator I = ModuleMgr.begin(),
6876       E = ModuleMgr.end(); I != E; ++I) {
6877     if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
6878       size_t bytes = buf->getBufferSize();
6879       switch (buf->getBufferKind()) {
6880         case llvm::MemoryBuffer::MemoryBuffer_Malloc:
6881           sizes.malloc_bytes += bytes;
6882           break;
6883         case llvm::MemoryBuffer::MemoryBuffer_MMap:
6884           sizes.mmap_bytes += bytes;
6885           break;
6886       }
6887     }
6888   }
6889 }
6890 
6891 void ASTReader::InitializeSema(Sema &S) {
6892   SemaObj = &S;
6893   S.addExternalSource(this);
6894 
6895   // Makes sure any declarations that were deserialized "too early"
6896   // still get added to the identifier's declaration chains.
6897   for (uint64_t ID : PreloadedDeclIDs) {
6898     NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
6899     pushExternalDeclIntoScope(D, D->getDeclName());
6900   }
6901   PreloadedDeclIDs.clear();
6902 
6903   // FIXME: What happens if these are changed by a module import?
6904   if (!FPPragmaOptions.empty()) {
6905     assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
6906     SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
6907   }
6908 
6909   // FIXME: What happens if these are changed by a module import?
6910   if (!OpenCLExtensions.empty()) {
6911     unsigned I = 0;
6912 #define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
6913 #include "clang/Basic/OpenCLExtensions.def"
6914 
6915     assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
6916   }
6917 
6918   UpdateSema();
6919 }
6920 
6921 void ASTReader::UpdateSema() {
6922   assert(SemaObj && "no Sema to update");
6923 
6924   // Load the offsets of the declarations that Sema references.
6925   // They will be lazily deserialized when needed.
6926   if (!SemaDeclRefs.empty()) {
6927     assert(SemaDeclRefs.size() % 2 == 0);
6928     for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) {
6929       if (!SemaObj->StdNamespace)
6930         SemaObj->StdNamespace = SemaDeclRefs[I];
6931       if (!SemaObj->StdBadAlloc)
6932         SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
6933     }
6934     SemaDeclRefs.clear();
6935   }
6936 
6937   // Update the state of 'pragma clang optimize'. Use the same API as if we had
6938   // encountered the pragma in the source.
6939   if(OptimizeOffPragmaLocation.isValid())
6940     SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
6941 }
6942 
6943 IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
6944   // Note that we are loading an identifier.
6945   Deserializing AnIdentifier(this);
6946   StringRef Name(NameStart, NameEnd - NameStart);
6947 
6948   // If there is a global index, look there first to determine which modules
6949   // provably do not have any results for this identifier.
6950   GlobalModuleIndex::HitSet Hits;
6951   GlobalModuleIndex::HitSet *HitsPtr = nullptr;
6952   if (!loadGlobalIndex()) {
6953     if (GlobalIndex->lookupIdentifier(Name, Hits)) {
6954       HitsPtr = &Hits;
6955     }
6956   }
6957   IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
6958                                   NumIdentifierLookups,
6959                                   NumIdentifierLookupHits);
6960   ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr);
6961   IdentifierInfo *II = Visitor.getIdentifierInfo();
6962   markIdentifierUpToDate(II);
6963   return II;
6964 }
6965 
6966 namespace clang {
6967   /// \brief An identifier-lookup iterator that enumerates all of the
6968   /// identifiers stored within a set of AST files.
6969   class ASTIdentifierIterator : public IdentifierIterator {
6970     /// \brief The AST reader whose identifiers are being enumerated.
6971     const ASTReader &Reader;
6972 
6973     /// \brief The current index into the chain of AST files stored in
6974     /// the AST reader.
6975     unsigned Index;
6976 
6977     /// \brief The current position within the identifier lookup table
6978     /// of the current AST file.
6979     ASTIdentifierLookupTable::key_iterator Current;
6980 
6981     /// \brief The end position within the identifier lookup table of
6982     /// the current AST file.
6983     ASTIdentifierLookupTable::key_iterator End;
6984 
6985   public:
6986     explicit ASTIdentifierIterator(const ASTReader &Reader);
6987 
6988     StringRef Next() override;
6989   };
6990 }
6991 
6992 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
6993   : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
6994   ASTIdentifierLookupTable *IdTable
6995     = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
6996   Current = IdTable->key_begin();
6997   End = IdTable->key_end();
6998 }
6999 
7000 StringRef ASTIdentifierIterator::Next() {
7001   while (Current == End) {
7002     // If we have exhausted all of our AST files, we're done.
7003     if (Index == 0)
7004       return StringRef();
7005 
7006     --Index;
7007     ASTIdentifierLookupTable *IdTable
7008       = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
7009         IdentifierLookupTable;
7010     Current = IdTable->key_begin();
7011     End = IdTable->key_end();
7012   }
7013 
7014   // We have any identifiers remaining in the current AST file; return
7015   // the next one.
7016   StringRef Result = *Current;
7017   ++Current;
7018   return Result;
7019 }
7020 
7021 IdentifierIterator *ASTReader::getIdentifiers() {
7022   if (!loadGlobalIndex())
7023     return GlobalIndex->createIdentifierIterator();
7024 
7025   return new ASTIdentifierIterator(*this);
7026 }
7027 
7028 namespace clang { namespace serialization {
7029   class ReadMethodPoolVisitor {
7030     ASTReader &Reader;
7031     Selector Sel;
7032     unsigned PriorGeneration;
7033     unsigned InstanceBits;
7034     unsigned FactoryBits;
7035     SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7036     SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
7037 
7038   public:
7039     ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
7040                           unsigned PriorGeneration)
7041       : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
7042         InstanceBits(0), FactoryBits(0) { }
7043 
7044     static bool visit(ModuleFile &M, void *UserData) {
7045       ReadMethodPoolVisitor *This
7046         = static_cast<ReadMethodPoolVisitor *>(UserData);
7047 
7048       if (!M.SelectorLookupTable)
7049         return false;
7050 
7051       // If we've already searched this module file, skip it now.
7052       if (M.Generation <= This->PriorGeneration)
7053         return true;
7054 
7055       ++This->Reader.NumMethodPoolTableLookups;
7056       ASTSelectorLookupTable *PoolTable
7057         = (ASTSelectorLookupTable*)M.SelectorLookupTable;
7058       ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
7059       if (Pos == PoolTable->end())
7060         return false;
7061 
7062       ++This->Reader.NumMethodPoolTableHits;
7063       ++This->Reader.NumSelectorsRead;
7064       // FIXME: Not quite happy with the statistics here. We probably should
7065       // disable this tracking when called via LoadSelector.
7066       // Also, should entries without methods count as misses?
7067       ++This->Reader.NumMethodPoolEntriesRead;
7068       ASTSelectorLookupTrait::data_type Data = *Pos;
7069       if (This->Reader.DeserializationListener)
7070         This->Reader.DeserializationListener->SelectorRead(Data.ID,
7071                                                            This->Sel);
7072 
7073       This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7074       This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7075       This->InstanceBits = Data.InstanceBits;
7076       This->FactoryBits = Data.FactoryBits;
7077       return true;
7078     }
7079 
7080     /// \brief Retrieve the instance methods found by this visitor.
7081     ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
7082       return InstanceMethods;
7083     }
7084 
7085     /// \brief Retrieve the instance methods found by this visitor.
7086     ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
7087       return FactoryMethods;
7088     }
7089 
7090     unsigned getInstanceBits() const { return InstanceBits; }
7091     unsigned getFactoryBits() const { return FactoryBits; }
7092   };
7093 } } // end namespace clang::serialization
7094 
7095 /// \brief Add the given set of methods to the method list.
7096 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
7097                              ObjCMethodList &List) {
7098   for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7099     S.addMethodToGlobalList(&List, Methods[I]);
7100   }
7101 }
7102 
7103 void ASTReader::ReadMethodPool(Selector Sel) {
7104   // Get the selector generation and update it to the current generation.
7105   unsigned &Generation = SelectorGeneration[Sel];
7106   unsigned PriorGeneration = Generation;
7107   Generation = getGeneration();
7108 
7109   // Search for methods defined with this selector.
7110   ++NumMethodPoolLookups;
7111   ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
7112   ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
7113 
7114   if (Visitor.getInstanceMethods().empty() &&
7115       Visitor.getFactoryMethods().empty())
7116     return;
7117 
7118   ++NumMethodPoolHits;
7119 
7120   if (!getSema())
7121     return;
7122 
7123   Sema &S = *getSema();
7124   Sema::GlobalMethodPool::iterator Pos
7125     = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
7126 
7127   addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7128   addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
7129   Pos->second.first.setBits(Visitor.getInstanceBits());
7130   Pos->second.second.setBits(Visitor.getFactoryBits());
7131 }
7132 
7133 void ASTReader::ReadKnownNamespaces(
7134                           SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7135   Namespaces.clear();
7136 
7137   for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7138     if (NamespaceDecl *Namespace
7139                 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7140       Namespaces.push_back(Namespace);
7141   }
7142 }
7143 
7144 void ASTReader::ReadUndefinedButUsed(
7145                         llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) {
7146   for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7147     NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
7148     SourceLocation Loc =
7149         SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
7150     Undefined.insert(std::make_pair(D, Loc));
7151   }
7152 }
7153 
7154 void ASTReader::ReadTentativeDefinitions(
7155                   SmallVectorImpl<VarDecl *> &TentativeDefs) {
7156   for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
7157     VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
7158     if (Var)
7159       TentativeDefs.push_back(Var);
7160   }
7161   TentativeDefinitions.clear();
7162 }
7163 
7164 void ASTReader::ReadUnusedFileScopedDecls(
7165                                SmallVectorImpl<const DeclaratorDecl *> &Decls) {
7166   for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
7167     DeclaratorDecl *D
7168       = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
7169     if (D)
7170       Decls.push_back(D);
7171   }
7172   UnusedFileScopedDecls.clear();
7173 }
7174 
7175 void ASTReader::ReadDelegatingConstructors(
7176                                  SmallVectorImpl<CXXConstructorDecl *> &Decls) {
7177   for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
7178     CXXConstructorDecl *D
7179       = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
7180     if (D)
7181       Decls.push_back(D);
7182   }
7183   DelegatingCtorDecls.clear();
7184 }
7185 
7186 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
7187   for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
7188     TypedefNameDecl *D
7189       = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
7190     if (D)
7191       Decls.push_back(D);
7192   }
7193   ExtVectorDecls.clear();
7194 }
7195 
7196 void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
7197   for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
7198     CXXRecordDecl *D
7199       = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
7200     if (D)
7201       Decls.push_back(D);
7202   }
7203   DynamicClasses.clear();
7204 }
7205 
7206 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
7207     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
7208   for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
7209        ++I) {
7210     TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
7211         GetDecl(UnusedLocalTypedefNameCandidates[I]));
7212     if (D)
7213       Decls.insert(D);
7214   }
7215   UnusedLocalTypedefNameCandidates.clear();
7216 }
7217 
7218 void
7219 ASTReader::ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl *> &Decls) {
7220   for (unsigned I = 0, N = LocallyScopedExternCDecls.size(); I != N; ++I) {
7221     NamedDecl *D
7222       = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternCDecls[I]));
7223     if (D)
7224       Decls.push_back(D);
7225   }
7226   LocallyScopedExternCDecls.clear();
7227 }
7228 
7229 void ASTReader::ReadReferencedSelectors(
7230        SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7231   if (ReferencedSelectorsData.empty())
7232     return;
7233 
7234   // If there are @selector references added them to its pool. This is for
7235   // implementation of -Wselector.
7236   unsigned int DataSize = ReferencedSelectorsData.size()-1;
7237   unsigned I = 0;
7238   while (I < DataSize) {
7239     Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7240     SourceLocation SelLoc
7241       = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7242     Sels.push_back(std::make_pair(Sel, SelLoc));
7243   }
7244   ReferencedSelectorsData.clear();
7245 }
7246 
7247 void ASTReader::ReadWeakUndeclaredIdentifiers(
7248        SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7249   if (WeakUndeclaredIdentifiers.empty())
7250     return;
7251 
7252   for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7253     IdentifierInfo *WeakId
7254       = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7255     IdentifierInfo *AliasId
7256       = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7257     SourceLocation Loc
7258       = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7259     bool Used = WeakUndeclaredIdentifiers[I++];
7260     WeakInfo WI(AliasId, Loc);
7261     WI.setUsed(Used);
7262     WeakIDs.push_back(std::make_pair(WeakId, WI));
7263   }
7264   WeakUndeclaredIdentifiers.clear();
7265 }
7266 
7267 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
7268   for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7269     ExternalVTableUse VT;
7270     VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7271     VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7272     VT.DefinitionRequired = VTableUses[Idx++];
7273     VTables.push_back(VT);
7274   }
7275 
7276   VTableUses.clear();
7277 }
7278 
7279 void ASTReader::ReadPendingInstantiations(
7280        SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
7281   for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
7282     ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
7283     SourceLocation Loc
7284       = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
7285 
7286     Pending.push_back(std::make_pair(D, Loc));
7287   }
7288   PendingInstantiations.clear();
7289 }
7290 
7291 void ASTReader::ReadLateParsedTemplates(
7292     llvm::DenseMap<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
7293   for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
7294        /* In loop */) {
7295     FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
7296 
7297     LateParsedTemplate *LT = new LateParsedTemplate;
7298     LT->D = GetDecl(LateParsedTemplates[Idx++]);
7299 
7300     ModuleFile *F = getOwningModuleFile(LT->D);
7301     assert(F && "No module");
7302 
7303     unsigned TokN = LateParsedTemplates[Idx++];
7304     LT->Toks.reserve(TokN);
7305     for (unsigned T = 0; T < TokN; ++T)
7306       LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
7307 
7308     LPTMap[FD] = LT;
7309   }
7310 
7311   LateParsedTemplates.clear();
7312 }
7313 
7314 void ASTReader::LoadSelector(Selector Sel) {
7315   // It would be complicated to avoid reading the methods anyway. So don't.
7316   ReadMethodPool(Sel);
7317 }
7318 
7319 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
7320   assert(ID && "Non-zero identifier ID required");
7321   assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
7322   IdentifiersLoaded[ID - 1] = II;
7323   if (DeserializationListener)
7324     DeserializationListener->IdentifierRead(ID, II);
7325 }
7326 
7327 /// \brief Set the globally-visible declarations associated with the given
7328 /// identifier.
7329 ///
7330 /// If the AST reader is currently in a state where the given declaration IDs
7331 /// cannot safely be resolved, they are queued until it is safe to resolve
7332 /// them.
7333 ///
7334 /// \param II an IdentifierInfo that refers to one or more globally-visible
7335 /// declarations.
7336 ///
7337 /// \param DeclIDs the set of declaration IDs with the name @p II that are
7338 /// visible at global scope.
7339 ///
7340 /// \param Decls if non-null, this vector will be populated with the set of
7341 /// deserialized declarations. These declarations will not be pushed into
7342 /// scope.
7343 void
7344 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
7345                               const SmallVectorImpl<uint32_t> &DeclIDs,
7346                                    SmallVectorImpl<Decl *> *Decls) {
7347   if (NumCurrentElementsDeserializing && !Decls) {
7348     PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
7349     return;
7350   }
7351 
7352   for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
7353     if (!SemaObj) {
7354       // Queue this declaration so that it will be added to the
7355       // translation unit scope and identifier's declaration chain
7356       // once a Sema object is known.
7357       PreloadedDeclIDs.push_back(DeclIDs[I]);
7358       continue;
7359     }
7360 
7361     NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
7362 
7363     // If we're simply supposed to record the declarations, do so now.
7364     if (Decls) {
7365       Decls->push_back(D);
7366       continue;
7367     }
7368 
7369     // Introduce this declaration into the translation-unit scope
7370     // and add it to the declaration chain for this identifier, so
7371     // that (unqualified) name lookup will find it.
7372     pushExternalDeclIntoScope(D, II);
7373   }
7374 }
7375 
7376 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
7377   if (ID == 0)
7378     return nullptr;
7379 
7380   if (IdentifiersLoaded.empty()) {
7381     Error("no identifier table in AST file");
7382     return nullptr;
7383   }
7384 
7385   ID -= 1;
7386   if (!IdentifiersLoaded[ID]) {
7387     GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
7388     assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
7389     ModuleFile *M = I->second;
7390     unsigned Index = ID - M->BaseIdentifierID;
7391     const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
7392 
7393     // All of the strings in the AST file are preceded by a 16-bit length.
7394     // Extract that 16-bit length to avoid having to execute strlen().
7395     // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
7396     //  unsigned integers.  This is important to avoid integer overflow when
7397     //  we cast them to 'unsigned'.
7398     const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
7399     unsigned StrLen = (((unsigned) StrLenPtr[0])
7400                        | (((unsigned) StrLenPtr[1]) << 8)) - 1;
7401     IdentifiersLoaded[ID]
7402       = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
7403     if (DeserializationListener)
7404       DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
7405   }
7406 
7407   return IdentifiersLoaded[ID];
7408 }
7409 
7410 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
7411   return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
7412 }
7413 
7414 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
7415   if (LocalID < NUM_PREDEF_IDENT_IDS)
7416     return LocalID;
7417 
7418   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7419     = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
7420   assert(I != M.IdentifierRemap.end()
7421          && "Invalid index into identifier index remap");
7422 
7423   return LocalID + I->second;
7424 }
7425 
7426 MacroInfo *ASTReader::getMacro(MacroID ID) {
7427   if (ID == 0)
7428     return nullptr;
7429 
7430   if (MacrosLoaded.empty()) {
7431     Error("no macro table in AST file");
7432     return nullptr;
7433   }
7434 
7435   ID -= NUM_PREDEF_MACRO_IDS;
7436   if (!MacrosLoaded[ID]) {
7437     GlobalMacroMapType::iterator I
7438       = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
7439     assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
7440     ModuleFile *M = I->second;
7441     unsigned Index = ID - M->BaseMacroID;
7442     MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
7443 
7444     if (DeserializationListener)
7445       DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
7446                                          MacrosLoaded[ID]);
7447   }
7448 
7449   return MacrosLoaded[ID];
7450 }
7451 
7452 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
7453   if (LocalID < NUM_PREDEF_MACRO_IDS)
7454     return LocalID;
7455 
7456   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7457     = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
7458   assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
7459 
7460   return LocalID + I->second;
7461 }
7462 
7463 serialization::SubmoduleID
7464 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
7465   if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
7466     return LocalID;
7467 
7468   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7469     = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
7470   assert(I != M.SubmoduleRemap.end()
7471          && "Invalid index into submodule index remap");
7472 
7473   return LocalID + I->second;
7474 }
7475 
7476 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
7477   if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
7478     assert(GlobalID == 0 && "Unhandled global submodule ID");
7479     return nullptr;
7480   }
7481 
7482   if (GlobalID > SubmodulesLoaded.size()) {
7483     Error("submodule ID out of range in AST file");
7484     return nullptr;
7485   }
7486 
7487   return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
7488 }
7489 
7490 Module *ASTReader::getModule(unsigned ID) {
7491   return getSubmodule(ID);
7492 }
7493 
7494 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
7495   return DecodeSelector(getGlobalSelectorID(M, LocalID));
7496 }
7497 
7498 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
7499   if (ID == 0)
7500     return Selector();
7501 
7502   if (ID > SelectorsLoaded.size()) {
7503     Error("selector ID out of range in AST file");
7504     return Selector();
7505   }
7506 
7507   if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
7508     // Load this selector from the selector table.
7509     GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
7510     assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
7511     ModuleFile &M = *I->second;
7512     ASTSelectorLookupTrait Trait(*this, M);
7513     unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
7514     SelectorsLoaded[ID - 1] =
7515       Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
7516     if (DeserializationListener)
7517       DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
7518   }
7519 
7520   return SelectorsLoaded[ID - 1];
7521 }
7522 
7523 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
7524   return DecodeSelector(ID);
7525 }
7526 
7527 uint32_t ASTReader::GetNumExternalSelectors() {
7528   // ID 0 (the null selector) is considered an external selector.
7529   return getTotalNumSelectors() + 1;
7530 }
7531 
7532 serialization::SelectorID
7533 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
7534   if (LocalID < NUM_PREDEF_SELECTOR_IDS)
7535     return LocalID;
7536 
7537   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7538     = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
7539   assert(I != M.SelectorRemap.end()
7540          && "Invalid index into selector index remap");
7541 
7542   return LocalID + I->second;
7543 }
7544 
7545 DeclarationName
7546 ASTReader::ReadDeclarationName(ModuleFile &F,
7547                                const RecordData &Record, unsigned &Idx) {
7548   DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
7549   switch (Kind) {
7550   case DeclarationName::Identifier:
7551     return DeclarationName(GetIdentifierInfo(F, Record, Idx));
7552 
7553   case DeclarationName::ObjCZeroArgSelector:
7554   case DeclarationName::ObjCOneArgSelector:
7555   case DeclarationName::ObjCMultiArgSelector:
7556     return DeclarationName(ReadSelector(F, Record, Idx));
7557 
7558   case DeclarationName::CXXConstructorName:
7559     return Context.DeclarationNames.getCXXConstructorName(
7560                           Context.getCanonicalType(readType(F, Record, Idx)));
7561 
7562   case DeclarationName::CXXDestructorName:
7563     return Context.DeclarationNames.getCXXDestructorName(
7564                           Context.getCanonicalType(readType(F, Record, Idx)));
7565 
7566   case DeclarationName::CXXConversionFunctionName:
7567     return Context.DeclarationNames.getCXXConversionFunctionName(
7568                           Context.getCanonicalType(readType(F, Record, Idx)));
7569 
7570   case DeclarationName::CXXOperatorName:
7571     return Context.DeclarationNames.getCXXOperatorName(
7572                                        (OverloadedOperatorKind)Record[Idx++]);
7573 
7574   case DeclarationName::CXXLiteralOperatorName:
7575     return Context.DeclarationNames.getCXXLiteralOperatorName(
7576                                        GetIdentifierInfo(F, Record, Idx));
7577 
7578   case DeclarationName::CXXUsingDirective:
7579     return DeclarationName::getUsingDirectiveName();
7580   }
7581 
7582   llvm_unreachable("Invalid NameKind!");
7583 }
7584 
7585 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
7586                                        DeclarationNameLoc &DNLoc,
7587                                        DeclarationName Name,
7588                                       const RecordData &Record, unsigned &Idx) {
7589   switch (Name.getNameKind()) {
7590   case DeclarationName::CXXConstructorName:
7591   case DeclarationName::CXXDestructorName:
7592   case DeclarationName::CXXConversionFunctionName:
7593     DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
7594     break;
7595 
7596   case DeclarationName::CXXOperatorName:
7597     DNLoc.CXXOperatorName.BeginOpNameLoc
7598         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7599     DNLoc.CXXOperatorName.EndOpNameLoc
7600         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7601     break;
7602 
7603   case DeclarationName::CXXLiteralOperatorName:
7604     DNLoc.CXXLiteralOperatorName.OpNameLoc
7605         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7606     break;
7607 
7608   case DeclarationName::Identifier:
7609   case DeclarationName::ObjCZeroArgSelector:
7610   case DeclarationName::ObjCOneArgSelector:
7611   case DeclarationName::ObjCMultiArgSelector:
7612   case DeclarationName::CXXUsingDirective:
7613     break;
7614   }
7615 }
7616 
7617 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
7618                                         DeclarationNameInfo &NameInfo,
7619                                       const RecordData &Record, unsigned &Idx) {
7620   NameInfo.setName(ReadDeclarationName(F, Record, Idx));
7621   NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
7622   DeclarationNameLoc DNLoc;
7623   ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
7624   NameInfo.setInfo(DNLoc);
7625 }
7626 
7627 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
7628                                   const RecordData &Record, unsigned &Idx) {
7629   Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
7630   unsigned NumTPLists = Record[Idx++];
7631   Info.NumTemplParamLists = NumTPLists;
7632   if (NumTPLists) {
7633     Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
7634     for (unsigned i=0; i != NumTPLists; ++i)
7635       Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
7636   }
7637 }
7638 
7639 TemplateName
7640 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
7641                             unsigned &Idx) {
7642   TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
7643   switch (Kind) {
7644   case TemplateName::Template:
7645       return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
7646 
7647   case TemplateName::OverloadedTemplate: {
7648     unsigned size = Record[Idx++];
7649     UnresolvedSet<8> Decls;
7650     while (size--)
7651       Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
7652 
7653     return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
7654   }
7655 
7656   case TemplateName::QualifiedTemplate: {
7657     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7658     bool hasTemplKeyword = Record[Idx++];
7659     TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
7660     return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
7661   }
7662 
7663   case TemplateName::DependentTemplate: {
7664     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7665     if (Record[Idx++])  // isIdentifier
7666       return Context.getDependentTemplateName(NNS,
7667                                                GetIdentifierInfo(F, Record,
7668                                                                  Idx));
7669     return Context.getDependentTemplateName(NNS,
7670                                          (OverloadedOperatorKind)Record[Idx++]);
7671   }
7672 
7673   case TemplateName::SubstTemplateTemplateParm: {
7674     TemplateTemplateParmDecl *param
7675       = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7676     if (!param) return TemplateName();
7677     TemplateName replacement = ReadTemplateName(F, Record, Idx);
7678     return Context.getSubstTemplateTemplateParm(param, replacement);
7679   }
7680 
7681   case TemplateName::SubstTemplateTemplateParmPack: {
7682     TemplateTemplateParmDecl *Param
7683       = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7684     if (!Param)
7685       return TemplateName();
7686 
7687     TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
7688     if (ArgPack.getKind() != TemplateArgument::Pack)
7689       return TemplateName();
7690 
7691     return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
7692   }
7693   }
7694 
7695   llvm_unreachable("Unhandled template name kind!");
7696 }
7697 
7698 TemplateArgument
7699 ASTReader::ReadTemplateArgument(ModuleFile &F,
7700                                 const RecordData &Record, unsigned &Idx) {
7701   TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
7702   switch (Kind) {
7703   case TemplateArgument::Null:
7704     return TemplateArgument();
7705   case TemplateArgument::Type:
7706     return TemplateArgument(readType(F, Record, Idx));
7707   case TemplateArgument::Declaration: {
7708     ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
7709     return TemplateArgument(D, readType(F, Record, Idx));
7710   }
7711   case TemplateArgument::NullPtr:
7712     return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
7713   case TemplateArgument::Integral: {
7714     llvm::APSInt Value = ReadAPSInt(Record, Idx);
7715     QualType T = readType(F, Record, Idx);
7716     return TemplateArgument(Context, Value, T);
7717   }
7718   case TemplateArgument::Template:
7719     return TemplateArgument(ReadTemplateName(F, Record, Idx));
7720   case TemplateArgument::TemplateExpansion: {
7721     TemplateName Name = ReadTemplateName(F, Record, Idx);
7722     Optional<unsigned> NumTemplateExpansions;
7723     if (unsigned NumExpansions = Record[Idx++])
7724       NumTemplateExpansions = NumExpansions - 1;
7725     return TemplateArgument(Name, NumTemplateExpansions);
7726   }
7727   case TemplateArgument::Expression:
7728     return TemplateArgument(ReadExpr(F));
7729   case TemplateArgument::Pack: {
7730     unsigned NumArgs = Record[Idx++];
7731     TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
7732     for (unsigned I = 0; I != NumArgs; ++I)
7733       Args[I] = ReadTemplateArgument(F, Record, Idx);
7734     return TemplateArgument(Args, NumArgs);
7735   }
7736   }
7737 
7738   llvm_unreachable("Unhandled template argument kind!");
7739 }
7740 
7741 TemplateParameterList *
7742 ASTReader::ReadTemplateParameterList(ModuleFile &F,
7743                                      const RecordData &Record, unsigned &Idx) {
7744   SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
7745   SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
7746   SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
7747 
7748   unsigned NumParams = Record[Idx++];
7749   SmallVector<NamedDecl *, 16> Params;
7750   Params.reserve(NumParams);
7751   while (NumParams--)
7752     Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
7753 
7754   TemplateParameterList* TemplateParams =
7755     TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
7756                                   Params.data(), Params.size(), RAngleLoc);
7757   return TemplateParams;
7758 }
7759 
7760 void
7761 ASTReader::
7762 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
7763                          ModuleFile &F, const RecordData &Record,
7764                          unsigned &Idx) {
7765   unsigned NumTemplateArgs = Record[Idx++];
7766   TemplArgs.reserve(NumTemplateArgs);
7767   while (NumTemplateArgs--)
7768     TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
7769 }
7770 
7771 /// \brief Read a UnresolvedSet structure.
7772 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
7773                                   const RecordData &Record, unsigned &Idx) {
7774   unsigned NumDecls = Record[Idx++];
7775   Set.reserve(Context, NumDecls);
7776   while (NumDecls--) {
7777     DeclID ID = ReadDeclID(F, Record, Idx);
7778     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
7779     Set.addLazyDecl(Context, ID, AS);
7780   }
7781 }
7782 
7783 CXXBaseSpecifier
7784 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
7785                                 const RecordData &Record, unsigned &Idx) {
7786   bool isVirtual = static_cast<bool>(Record[Idx++]);
7787   bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
7788   AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
7789   bool inheritConstructors = static_cast<bool>(Record[Idx++]);
7790   TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
7791   SourceRange Range = ReadSourceRange(F, Record, Idx);
7792   SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
7793   CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
7794                           EllipsisLoc);
7795   Result.setInheritConstructors(inheritConstructors);
7796   return Result;
7797 }
7798 
7799 std::pair<CXXCtorInitializer **, unsigned>
7800 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
7801                                    unsigned &Idx) {
7802   CXXCtorInitializer **CtorInitializers = nullptr;
7803   unsigned NumInitializers = Record[Idx++];
7804   if (NumInitializers) {
7805     CtorInitializers
7806         = new (Context) CXXCtorInitializer*[NumInitializers];
7807     for (unsigned i=0; i != NumInitializers; ++i) {
7808       TypeSourceInfo *TInfo = nullptr;
7809       bool IsBaseVirtual = false;
7810       FieldDecl *Member = nullptr;
7811       IndirectFieldDecl *IndirectMember = nullptr;
7812 
7813       CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
7814       switch (Type) {
7815       case CTOR_INITIALIZER_BASE:
7816         TInfo = GetTypeSourceInfo(F, Record, Idx);
7817         IsBaseVirtual = Record[Idx++];
7818         break;
7819 
7820       case CTOR_INITIALIZER_DELEGATING:
7821         TInfo = GetTypeSourceInfo(F, Record, Idx);
7822         break;
7823 
7824        case CTOR_INITIALIZER_MEMBER:
7825         Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
7826         break;
7827 
7828        case CTOR_INITIALIZER_INDIRECT_MEMBER:
7829         IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
7830         break;
7831       }
7832 
7833       SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
7834       Expr *Init = ReadExpr(F);
7835       SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
7836       SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
7837       bool IsWritten = Record[Idx++];
7838       unsigned SourceOrderOrNumArrayIndices;
7839       SmallVector<VarDecl *, 8> Indices;
7840       if (IsWritten) {
7841         SourceOrderOrNumArrayIndices = Record[Idx++];
7842       } else {
7843         SourceOrderOrNumArrayIndices = Record[Idx++];
7844         Indices.reserve(SourceOrderOrNumArrayIndices);
7845         for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
7846           Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
7847       }
7848 
7849       CXXCtorInitializer *BOMInit;
7850       if (Type == CTOR_INITIALIZER_BASE) {
7851         BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual,
7852                                              LParenLoc, Init, RParenLoc,
7853                                              MemberOrEllipsisLoc);
7854       } else if (Type == CTOR_INITIALIZER_DELEGATING) {
7855         BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc,
7856                                                    Init, RParenLoc);
7857       } else if (IsWritten) {
7858         if (Member)
7859           BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
7860                                                LParenLoc, Init, RParenLoc);
7861         else
7862           BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
7863                                                MemberOrEllipsisLoc, LParenLoc,
7864                                                Init, RParenLoc);
7865       } else {
7866         if (IndirectMember) {
7867           assert(Indices.empty() && "Indirect field improperly initialized");
7868           BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
7869                                                      MemberOrEllipsisLoc, LParenLoc,
7870                                                      Init, RParenLoc);
7871         } else {
7872           BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc,
7873                                                LParenLoc, Init, RParenLoc,
7874                                                Indices.data(), Indices.size());
7875         }
7876       }
7877 
7878       if (IsWritten)
7879         BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
7880       CtorInitializers[i] = BOMInit;
7881     }
7882   }
7883 
7884   return std::make_pair(CtorInitializers, NumInitializers);
7885 }
7886 
7887 NestedNameSpecifier *
7888 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
7889                                    const RecordData &Record, unsigned &Idx) {
7890   unsigned N = Record[Idx++];
7891   NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
7892   for (unsigned I = 0; I != N; ++I) {
7893     NestedNameSpecifier::SpecifierKind Kind
7894       = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
7895     switch (Kind) {
7896     case NestedNameSpecifier::Identifier: {
7897       IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
7898       NNS = NestedNameSpecifier::Create(Context, Prev, II);
7899       break;
7900     }
7901 
7902     case NestedNameSpecifier::Namespace: {
7903       NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
7904       NNS = NestedNameSpecifier::Create(Context, Prev, NS);
7905       break;
7906     }
7907 
7908     case NestedNameSpecifier::NamespaceAlias: {
7909       NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
7910       NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
7911       break;
7912     }
7913 
7914     case NestedNameSpecifier::TypeSpec:
7915     case NestedNameSpecifier::TypeSpecWithTemplate: {
7916       const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
7917       if (!T)
7918         return nullptr;
7919 
7920       bool Template = Record[Idx++];
7921       NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
7922       break;
7923     }
7924 
7925     case NestedNameSpecifier::Global: {
7926       NNS = NestedNameSpecifier::GlobalSpecifier(Context);
7927       // No associated value, and there can't be a prefix.
7928       break;
7929     }
7930 
7931     case NestedNameSpecifier::Super: {
7932       CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
7933       NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
7934       break;
7935     }
7936     }
7937     Prev = NNS;
7938   }
7939   return NNS;
7940 }
7941 
7942 NestedNameSpecifierLoc
7943 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
7944                                       unsigned &Idx) {
7945   unsigned N = Record[Idx++];
7946   NestedNameSpecifierLocBuilder Builder;
7947   for (unsigned I = 0; I != N; ++I) {
7948     NestedNameSpecifier::SpecifierKind Kind
7949       = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
7950     switch (Kind) {
7951     case NestedNameSpecifier::Identifier: {
7952       IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
7953       SourceRange Range = ReadSourceRange(F, Record, Idx);
7954       Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
7955       break;
7956     }
7957 
7958     case NestedNameSpecifier::Namespace: {
7959       NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
7960       SourceRange Range = ReadSourceRange(F, Record, Idx);
7961       Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
7962       break;
7963     }
7964 
7965     case NestedNameSpecifier::NamespaceAlias: {
7966       NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
7967       SourceRange Range = ReadSourceRange(F, Record, Idx);
7968       Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
7969       break;
7970     }
7971 
7972     case NestedNameSpecifier::TypeSpec:
7973     case NestedNameSpecifier::TypeSpecWithTemplate: {
7974       bool Template = Record[Idx++];
7975       TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
7976       if (!T)
7977         return NestedNameSpecifierLoc();
7978       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
7979 
7980       // FIXME: 'template' keyword location not saved anywhere, so we fake it.
7981       Builder.Extend(Context,
7982                      Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
7983                      T->getTypeLoc(), ColonColonLoc);
7984       break;
7985     }
7986 
7987     case NestedNameSpecifier::Global: {
7988       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
7989       Builder.MakeGlobal(Context, ColonColonLoc);
7990       break;
7991     }
7992 
7993     case NestedNameSpecifier::Super: {
7994       CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
7995       SourceRange Range = ReadSourceRange(F, Record, Idx);
7996       Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
7997       break;
7998     }
7999     }
8000   }
8001 
8002   return Builder.getWithLocInContext(Context);
8003 }
8004 
8005 SourceRange
8006 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8007                            unsigned &Idx) {
8008   SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8009   SourceLocation end = ReadSourceLocation(F, Record, Idx);
8010   return SourceRange(beg, end);
8011 }
8012 
8013 /// \brief Read an integral value
8014 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8015   unsigned BitWidth = Record[Idx++];
8016   unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8017   llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8018   Idx += NumWords;
8019   return Result;
8020 }
8021 
8022 /// \brief Read a signed integral value
8023 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8024   bool isUnsigned = Record[Idx++];
8025   return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8026 }
8027 
8028 /// \brief Read a floating-point value
8029 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8030                                      const llvm::fltSemantics &Sem,
8031                                      unsigned &Idx) {
8032   return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8033 }
8034 
8035 // \brief Read a string
8036 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8037   unsigned Len = Record[Idx++];
8038   std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8039   Idx += Len;
8040   return Result;
8041 }
8042 
8043 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
8044                                          unsigned &Idx) {
8045   unsigned Major = Record[Idx++];
8046   unsigned Minor = Record[Idx++];
8047   unsigned Subminor = Record[Idx++];
8048   if (Minor == 0)
8049     return VersionTuple(Major);
8050   if (Subminor == 0)
8051     return VersionTuple(Major, Minor - 1);
8052   return VersionTuple(Major, Minor - 1, Subminor - 1);
8053 }
8054 
8055 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
8056                                           const RecordData &Record,
8057                                           unsigned &Idx) {
8058   CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8059   return CXXTemporary::Create(Context, Decl);
8060 }
8061 
8062 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
8063   return Diag(CurrentImportLoc, DiagID);
8064 }
8065 
8066 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
8067   return Diags.Report(Loc, DiagID);
8068 }
8069 
8070 /// \brief Retrieve the identifier table associated with the
8071 /// preprocessor.
8072 IdentifierTable &ASTReader::getIdentifierTable() {
8073   return PP.getIdentifierTable();
8074 }
8075 
8076 /// \brief Record that the given ID maps to the given switch-case
8077 /// statement.
8078 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
8079   assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8080          "Already have a SwitchCase with this ID");
8081   (*CurrSwitchCaseStmts)[ID] = SC;
8082 }
8083 
8084 /// \brief Retrieve the switch-case statement with the given ID.
8085 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
8086   assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8087   return (*CurrSwitchCaseStmts)[ID];
8088 }
8089 
8090 void ASTReader::ClearSwitchCaseIDs() {
8091   CurrSwitchCaseStmts->clear();
8092 }
8093 
8094 void ASTReader::ReadComments() {
8095   std::vector<RawComment *> Comments;
8096   for (SmallVectorImpl<std::pair<BitstreamCursor,
8097                                  serialization::ModuleFile *> >::iterator
8098        I = CommentsCursors.begin(),
8099        E = CommentsCursors.end();
8100        I != E; ++I) {
8101     Comments.clear();
8102     BitstreamCursor &Cursor = I->first;
8103     serialization::ModuleFile &F = *I->second;
8104     SavedStreamPosition SavedPosition(Cursor);
8105 
8106     RecordData Record;
8107     while (true) {
8108       llvm::BitstreamEntry Entry =
8109         Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
8110 
8111       switch (Entry.Kind) {
8112       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8113       case llvm::BitstreamEntry::Error:
8114         Error("malformed block record in AST file");
8115         return;
8116       case llvm::BitstreamEntry::EndBlock:
8117         goto NextCursor;
8118       case llvm::BitstreamEntry::Record:
8119         // The interesting case.
8120         break;
8121       }
8122 
8123       // Read a record.
8124       Record.clear();
8125       switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
8126       case COMMENTS_RAW_COMMENT: {
8127         unsigned Idx = 0;
8128         SourceRange SR = ReadSourceRange(F, Record, Idx);
8129         RawComment::CommentKind Kind =
8130             (RawComment::CommentKind) Record[Idx++];
8131         bool IsTrailingComment = Record[Idx++];
8132         bool IsAlmostTrailingComment = Record[Idx++];
8133         Comments.push_back(new (Context) RawComment(
8134             SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8135             Context.getLangOpts().CommentOpts.ParseAllComments));
8136         break;
8137       }
8138       }
8139     }
8140   NextCursor:
8141     Context.Comments.addDeserializedComments(Comments);
8142   }
8143 }
8144 
8145 void ASTReader::getInputFiles(ModuleFile &F,
8146                              SmallVectorImpl<serialization::InputFile> &Files) {
8147   for (unsigned I = 0, E = F.InputFilesLoaded.size(); I != E; ++I) {
8148     unsigned ID = I+1;
8149     Files.push_back(getInputFile(F, ID));
8150   }
8151 }
8152 
8153 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
8154   // If we know the owning module, use it.
8155   if (Module *M = D->getOwningModule())
8156     return M->getFullModuleName();
8157 
8158   // Otherwise, use the name of the top-level module the decl is within.
8159   if (ModuleFile *M = getOwningModuleFile(D))
8160     return M->ModuleName;
8161 
8162   // Not from a module.
8163   return "";
8164 }
8165 
8166 void ASTReader::finishPendingActions() {
8167   while (!PendingIdentifierInfos.empty() ||
8168          !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
8169          !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
8170          !PendingUpdateRecords.empty()) {
8171     // If any identifiers with corresponding top-level declarations have
8172     // been loaded, load those declarations now.
8173     typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8174       TopLevelDeclsMap;
8175     TopLevelDeclsMap TopLevelDecls;
8176 
8177     while (!PendingIdentifierInfos.empty()) {
8178       IdentifierInfo *II = PendingIdentifierInfos.back().first;
8179       SmallVector<uint32_t, 4> DeclIDs =
8180           std::move(PendingIdentifierInfos.back().second);
8181       PendingIdentifierInfos.pop_back();
8182 
8183       SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
8184     }
8185 
8186     // For each decl chain that we wanted to complete while deserializing, mark
8187     // it as "still needs to be completed".
8188     for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
8189       markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
8190     }
8191     PendingIncompleteDeclChains.clear();
8192 
8193     // Load pending declaration chains.
8194     for (unsigned I = 0; I != PendingDeclChains.size(); ++I) {
8195       loadPendingDeclChain(PendingDeclChains[I]);
8196       PendingDeclChainsKnown.erase(PendingDeclChains[I]);
8197     }
8198     PendingDeclChains.clear();
8199 
8200     // Make the most recent of the top-level declarations visible.
8201     for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
8202            TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
8203       IdentifierInfo *II = TLD->first;
8204       for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
8205         pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
8206       }
8207     }
8208 
8209     // Load any pending macro definitions.
8210     for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
8211       IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
8212       SmallVector<PendingMacroInfo, 2> GlobalIDs;
8213       GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
8214       // Initialize the macro history from chained-PCHs ahead of module imports.
8215       for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8216            ++IDIdx) {
8217         const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8218         if (Info.M->Kind != MK_ImplicitModule &&
8219             Info.M->Kind != MK_ExplicitModule)
8220           resolvePendingMacro(II, Info);
8221       }
8222       // Handle module imports.
8223       for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8224            ++IDIdx) {
8225         const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8226         if (Info.M->Kind == MK_ImplicitModule ||
8227             Info.M->Kind == MK_ExplicitModule)
8228           resolvePendingMacro(II, Info);
8229       }
8230     }
8231     PendingMacroIDs.clear();
8232 
8233     // Wire up the DeclContexts for Decls that we delayed setting until
8234     // recursive loading is completed.
8235     while (!PendingDeclContextInfos.empty()) {
8236       PendingDeclContextInfo Info = PendingDeclContextInfos.front();
8237       PendingDeclContextInfos.pop_front();
8238       DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
8239       DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
8240       Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
8241     }
8242 
8243     // Perform any pending declaration updates.
8244     while (!PendingUpdateRecords.empty()) {
8245       auto Update = PendingUpdateRecords.pop_back_val();
8246       ReadingKindTracker ReadingKind(Read_Decl, *this);
8247       loadDeclUpdateRecords(Update.first, Update.second);
8248     }
8249   }
8250 
8251   // If we deserialized any C++ or Objective-C class definitions, any
8252   // Objective-C protocol definitions, or any redeclarable templates, make sure
8253   // that all redeclarations point to the definitions. Note that this can only
8254   // happen now, after the redeclaration chains have been fully wired.
8255   for (Decl *D : PendingDefinitions) {
8256     if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
8257       if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
8258         // Make sure that the TagType points at the definition.
8259         const_cast<TagType*>(TagT)->decl = TD;
8260       }
8261 
8262       if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
8263         for (auto R : RD->redecls()) {
8264           assert((R == D) == R->isThisDeclarationADefinition() &&
8265                  "declaration thinks it's the definition but it isn't");
8266           cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
8267         }
8268       }
8269 
8270       continue;
8271     }
8272 
8273     if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
8274       // Make sure that the ObjCInterfaceType points at the definition.
8275       const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
8276         ->Decl = ID;
8277 
8278       for (auto R : ID->redecls())
8279         R->Data = ID->Data;
8280 
8281       continue;
8282     }
8283 
8284     if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
8285       for (auto R : PD->redecls())
8286         R->Data = PD->Data;
8287 
8288       continue;
8289     }
8290 
8291     auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
8292     for (auto R : RTD->redecls())
8293       R->Common = RTD->Common;
8294   }
8295   PendingDefinitions.clear();
8296 
8297   // Load the bodies of any functions or methods we've encountered. We do
8298   // this now (delayed) so that we can be sure that the declaration chains
8299   // have been fully wired up.
8300   for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
8301                                PBEnd = PendingBodies.end();
8302        PB != PBEnd; ++PB) {
8303     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
8304       // FIXME: Check for =delete/=default?
8305       // FIXME: Complain about ODR violations here?
8306       if (!getContext().getLangOpts().Modules || !FD->hasBody())
8307         FD->setLazyBody(PB->second);
8308       continue;
8309     }
8310 
8311     ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
8312     if (!getContext().getLangOpts().Modules || !MD->hasBody())
8313       MD->setLazyBody(PB->second);
8314   }
8315   PendingBodies.clear();
8316 }
8317 
8318 void ASTReader::diagnoseOdrViolations() {
8319   if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
8320     return;
8321 
8322   // Trigger the import of the full definition of each class that had any
8323   // odr-merging problems, so we can produce better diagnostics for them.
8324   // These updates may in turn find and diagnose some ODR failures, so take
8325   // ownership of the set first.
8326   auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
8327   PendingOdrMergeFailures.clear();
8328   for (auto &Merge : OdrMergeFailures) {
8329     Merge.first->buildLookup();
8330     Merge.first->decls_begin();
8331     Merge.first->bases_begin();
8332     Merge.first->vbases_begin();
8333     for (auto *RD : Merge.second) {
8334       RD->decls_begin();
8335       RD->bases_begin();
8336       RD->vbases_begin();
8337     }
8338   }
8339 
8340   // For each declaration from a merged context, check that the canonical
8341   // definition of that context also contains a declaration of the same
8342   // entity.
8343   //
8344   // Caution: this loop does things that might invalidate iterators into
8345   // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
8346   while (!PendingOdrMergeChecks.empty()) {
8347     NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
8348 
8349     // FIXME: Skip over implicit declarations for now. This matters for things
8350     // like implicitly-declared special member functions. This isn't entirely
8351     // correct; we can end up with multiple unmerged declarations of the same
8352     // implicit entity.
8353     if (D->isImplicit())
8354       continue;
8355 
8356     DeclContext *CanonDef = D->getDeclContext();
8357 
8358     bool Found = false;
8359     const Decl *DCanon = D->getCanonicalDecl();
8360 
8361     for (auto RI : D->redecls()) {
8362       if (RI->getLexicalDeclContext() == CanonDef) {
8363         Found = true;
8364         break;
8365       }
8366     }
8367     if (Found)
8368       continue;
8369 
8370     llvm::SmallVector<const NamedDecl*, 4> Candidates;
8371     DeclContext::lookup_result R = CanonDef->lookup(D->getDeclName());
8372     for (DeclContext::lookup_iterator I = R.begin(), E = R.end();
8373          !Found && I != E; ++I) {
8374       for (auto RI : (*I)->redecls()) {
8375         if (RI->getLexicalDeclContext() == CanonDef) {
8376           // This declaration is present in the canonical definition. If it's
8377           // in the same redecl chain, it's the one we're looking for.
8378           if (RI->getCanonicalDecl() == DCanon)
8379             Found = true;
8380           else
8381             Candidates.push_back(cast<NamedDecl>(RI));
8382           break;
8383         }
8384       }
8385     }
8386 
8387     if (!Found) {
8388       // The AST doesn't like TagDecls becoming invalid after they've been
8389       // completed. We only really need to mark FieldDecls as invalid here.
8390       if (!isa<TagDecl>(D))
8391         D->setInvalidDecl();
8392 
8393       std::string CanonDefModule =
8394           getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
8395       Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
8396         << D << getOwningModuleNameForDiagnostic(D)
8397         << CanonDef << CanonDefModule.empty() << CanonDefModule;
8398 
8399       if (Candidates.empty())
8400         Diag(cast<Decl>(CanonDef)->getLocation(),
8401              diag::note_module_odr_violation_no_possible_decls) << D;
8402       else {
8403         for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
8404           Diag(Candidates[I]->getLocation(),
8405                diag::note_module_odr_violation_possible_decl)
8406             << Candidates[I];
8407       }
8408 
8409       DiagnosedOdrMergeFailures.insert(CanonDef);
8410     }
8411   }
8412 
8413   // Issue any pending ODR-failure diagnostics.
8414   for (auto &Merge : OdrMergeFailures) {
8415     // If we've already pointed out a specific problem with this class, don't
8416     // bother issuing a general "something's different" diagnostic.
8417     if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
8418       continue;
8419 
8420     bool Diagnosed = false;
8421     for (auto *RD : Merge.second) {
8422       // Multiple different declarations got merged together; tell the user
8423       // where they came from.
8424       if (Merge.first != RD) {
8425         // FIXME: Walk the definition, figure out what's different,
8426         // and diagnose that.
8427         if (!Diagnosed) {
8428           std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
8429           Diag(Merge.first->getLocation(),
8430                diag::err_module_odr_violation_different_definitions)
8431             << Merge.first << Module.empty() << Module;
8432           Diagnosed = true;
8433         }
8434 
8435         Diag(RD->getLocation(),
8436              diag::note_module_odr_violation_different_definitions)
8437           << getOwningModuleNameForDiagnostic(RD);
8438       }
8439     }
8440 
8441     if (!Diagnosed) {
8442       // All definitions are updates to the same declaration. This happens if a
8443       // module instantiates the declaration of a class template specialization
8444       // and two or more other modules instantiate its definition.
8445       //
8446       // FIXME: Indicate which modules had instantiations of this definition.
8447       // FIXME: How can this even happen?
8448       Diag(Merge.first->getLocation(),
8449            diag::err_module_odr_violation_different_instantiations)
8450         << Merge.first;
8451     }
8452   }
8453 }
8454 
8455 void ASTReader::FinishedDeserializing() {
8456   assert(NumCurrentElementsDeserializing &&
8457          "FinishedDeserializing not paired with StartedDeserializing");
8458   if (NumCurrentElementsDeserializing == 1) {
8459     // We decrease NumCurrentElementsDeserializing only after pending actions
8460     // are finished, to avoid recursively re-calling finishPendingActions().
8461     finishPendingActions();
8462   }
8463   --NumCurrentElementsDeserializing;
8464 
8465   if (NumCurrentElementsDeserializing == 0) {
8466     diagnoseOdrViolations();
8467 
8468     // We are not in recursive loading, so it's safe to pass the "interesting"
8469     // decls to the consumer.
8470     if (Consumer)
8471       PassInterestingDeclsToConsumer();
8472   }
8473 }
8474 
8475 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
8476   D = D->getMostRecentDecl();
8477 
8478   if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
8479     SemaObj->TUScope->AddDecl(D);
8480   } else if (SemaObj->TUScope) {
8481     // Adding the decl to IdResolver may have failed because it was already in
8482     // (even though it was not added in scope). If it is already in, make sure
8483     // it gets in the scope as well.
8484     if (std::find(SemaObj->IdResolver.begin(Name),
8485                   SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
8486       SemaObj->TUScope->AddDecl(D);
8487   }
8488 }
8489 
8490 ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, StringRef isysroot,
8491                      bool DisableValidation, bool AllowASTWithCompilerErrors,
8492                      bool AllowConfigurationMismatch, bool ValidateSystemInputs,
8493                      bool UseGlobalIndex)
8494     : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr),
8495       OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
8496       FileMgr(PP.getFileManager()), Diags(PP.getDiagnostics()),
8497       SemaObj(nullptr), PP(PP), Context(Context), Consumer(nullptr),
8498       ModuleMgr(PP.getFileManager()), isysroot(isysroot),
8499       DisableValidation(DisableValidation),
8500       AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
8501       AllowConfigurationMismatch(AllowConfigurationMismatch),
8502       ValidateSystemInputs(ValidateSystemInputs),
8503       UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
8504       CurrSwitchCaseStmts(&SwitchCaseStmts),
8505       NumSLocEntriesRead(0), TotalNumSLocEntries(0), NumStatementsRead(0),
8506       TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
8507       NumIdentifierLookups(0), NumIdentifierLookupHits(0), NumSelectorsRead(0),
8508       NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
8509       NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
8510       NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
8511       NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
8512       NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
8513       TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
8514       PassingDeclsToConsumer(false), NumCXXBaseSpecifiersLoaded(0),
8515       ReadingKind(Read_None) {
8516   SourceMgr.setExternalSLocEntrySource(this);
8517 }
8518 
8519 ASTReader::~ASTReader() {
8520   if (OwnsDeserializationListener)
8521     delete DeserializationListener;
8522 
8523   for (DeclContextVisibleUpdatesPending::iterator
8524            I = PendingVisibleUpdates.begin(),
8525            E = PendingVisibleUpdates.end();
8526        I != E; ++I) {
8527     for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
8528                                              F = I->second.end();
8529          J != F; ++J)
8530       delete J->first;
8531   }
8532 }
8533