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