[clang] Adopt new FileManager error-returning APIs
[lldb.git] / clang / lib / Serialization / ASTReader.cpp
1 //===- ASTReader.cpp - AST File Reader ------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 //  This file defines the ASTReader class, which reads AST files.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/Serialization/ASTReader.h"
14 #include "ASTCommon.h"
15 #include "ASTReaderInternals.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/ASTMutationListener.h"
19 #include "clang/AST/ASTUnresolvedSet.h"
20 #include "clang/AST/Decl.h"
21 #include "clang/AST/DeclBase.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/DeclFriend.h"
24 #include "clang/AST/DeclGroup.h"
25 #include "clang/AST/DeclObjC.h"
26 #include "clang/AST/DeclTemplate.h"
27 #include "clang/AST/DeclarationName.h"
28 #include "clang/AST/Expr.h"
29 #include "clang/AST/ExprCXX.h"
30 #include "clang/AST/ExternalASTSource.h"
31 #include "clang/AST/NestedNameSpecifier.h"
32 #include "clang/AST/ODRHash.h"
33 #include "clang/AST/RawCommentList.h"
34 #include "clang/AST/TemplateBase.h"
35 #include "clang/AST/TemplateName.h"
36 #include "clang/AST/Type.h"
37 #include "clang/AST/TypeLoc.h"
38 #include "clang/AST/TypeLocVisitor.h"
39 #include "clang/AST/UnresolvedSet.h"
40 #include "clang/Basic/CommentOptions.h"
41 #include "clang/Basic/Diagnostic.h"
42 #include "clang/Basic/DiagnosticOptions.h"
43 #include "clang/Basic/ExceptionSpecificationType.h"
44 #include "clang/Basic/FileManager.h"
45 #include "clang/Basic/FileSystemOptions.h"
46 #include "clang/Basic/IdentifierTable.h"
47 #include "clang/Basic/LLVM.h"
48 #include "clang/Basic/LangOptions.h"
49 #include "clang/Basic/Module.h"
50 #include "clang/Basic/ObjCRuntime.h"
51 #include "clang/Basic/OperatorKinds.h"
52 #include "clang/Basic/PragmaKinds.h"
53 #include "clang/Basic/Sanitizers.h"
54 #include "clang/Basic/SourceLocation.h"
55 #include "clang/Basic/SourceManager.h"
56 #include "clang/Basic/SourceManagerInternals.h"
57 #include "clang/Basic/Specifiers.h"
58 #include "clang/Basic/TargetInfo.h"
59 #include "clang/Basic/TargetOptions.h"
60 #include "clang/Basic/TokenKinds.h"
61 #include "clang/Basic/Version.h"
62 #include "clang/Lex/HeaderSearch.h"
63 #include "clang/Lex/HeaderSearchOptions.h"
64 #include "clang/Lex/MacroInfo.h"
65 #include "clang/Lex/ModuleMap.h"
66 #include "clang/Lex/PreprocessingRecord.h"
67 #include "clang/Lex/Preprocessor.h"
68 #include "clang/Lex/PreprocessorOptions.h"
69 #include "clang/Lex/Token.h"
70 #include "clang/Sema/ObjCMethodList.h"
71 #include "clang/Sema/Scope.h"
72 #include "clang/Sema/Sema.h"
73 #include "clang/Sema/Weak.h"
74 #include "clang/Serialization/ASTBitCodes.h"
75 #include "clang/Serialization/ASTDeserializationListener.h"
76 #include "clang/Serialization/ContinuousRangeMap.h"
77 #include "clang/Serialization/GlobalModuleIndex.h"
78 #include "clang/Serialization/InMemoryModuleCache.h"
79 #include "clang/Serialization/Module.h"
80 #include "clang/Serialization/ModuleFileExtension.h"
81 #include "clang/Serialization/ModuleManager.h"
82 #include "clang/Serialization/PCHContainerOperations.h"
83 #include "clang/Serialization/SerializationDiagnostic.h"
84 #include "llvm/ADT/APFloat.h"
85 #include "llvm/ADT/APInt.h"
86 #include "llvm/ADT/APSInt.h"
87 #include "llvm/ADT/ArrayRef.h"
88 #include "llvm/ADT/DenseMap.h"
89 #include "llvm/ADT/FoldingSet.h"
90 #include "llvm/ADT/Hashing.h"
91 #include "llvm/ADT/IntrusiveRefCntPtr.h"
92 #include "llvm/ADT/None.h"
93 #include "llvm/ADT/Optional.h"
94 #include "llvm/ADT/STLExtras.h"
95 #include "llvm/ADT/ScopeExit.h"
96 #include "llvm/ADT/SmallPtrSet.h"
97 #include "llvm/ADT/SmallString.h"
98 #include "llvm/ADT/SmallVector.h"
99 #include "llvm/ADT/StringExtras.h"
100 #include "llvm/ADT/StringMap.h"
101 #include "llvm/ADT/StringRef.h"
102 #include "llvm/ADT/Triple.h"
103 #include "llvm/ADT/iterator_range.h"
104 #include "llvm/Bitstream/BitstreamReader.h"
105 #include "llvm/Support/Casting.h"
106 #include "llvm/Support/Compiler.h"
107 #include "llvm/Support/Compression.h"
108 #include "llvm/Support/DJB.h"
109 #include "llvm/Support/Endian.h"
110 #include "llvm/Support/Error.h"
111 #include "llvm/Support/ErrorHandling.h"
112 #include "llvm/Support/FileSystem.h"
113 #include "llvm/Support/MemoryBuffer.h"
114 #include "llvm/Support/Path.h"
115 #include "llvm/Support/SaveAndRestore.h"
116 #include "llvm/Support/Timer.h"
117 #include "llvm/Support/VersionTuple.h"
118 #include "llvm/Support/raw_ostream.h"
119 #include <algorithm>
120 #include <cassert>
121 #include <cstddef>
122 #include <cstdint>
123 #include <cstdio>
124 #include <ctime>
125 #include <iterator>
126 #include <limits>
127 #include <map>
128 #include <memory>
129 #include <string>
130 #include <system_error>
131 #include <tuple>
132 #include <utility>
133 #include <vector>
134
135 using namespace clang;
136 using namespace clang::serialization;
137 using namespace clang::serialization::reader;
138 using llvm::BitstreamCursor;
139
140 //===----------------------------------------------------------------------===//
141 // ChainedASTReaderListener implementation
142 //===----------------------------------------------------------------------===//
143
144 bool
145 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
146   return First->ReadFullVersionInformation(FullVersion) ||
147          Second->ReadFullVersionInformation(FullVersion);
148 }
149
150 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
151   First->ReadModuleName(ModuleName);
152   Second->ReadModuleName(ModuleName);
153 }
154
155 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
156   First->ReadModuleMapFile(ModuleMapPath);
157   Second->ReadModuleMapFile(ModuleMapPath);
158 }
159
160 bool
161 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
162                                               bool Complain,
163                                               bool AllowCompatibleDifferences) {
164   return First->ReadLanguageOptions(LangOpts, Complain,
165                                     AllowCompatibleDifferences) ||
166          Second->ReadLanguageOptions(LangOpts, Complain,
167                                      AllowCompatibleDifferences);
168 }
169
170 bool ChainedASTReaderListener::ReadTargetOptions(
171     const TargetOptions &TargetOpts, bool Complain,
172     bool AllowCompatibleDifferences) {
173   return First->ReadTargetOptions(TargetOpts, Complain,
174                                   AllowCompatibleDifferences) ||
175          Second->ReadTargetOptions(TargetOpts, Complain,
176                                    AllowCompatibleDifferences);
177 }
178
179 bool ChainedASTReaderListener::ReadDiagnosticOptions(
180     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
181   return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
182          Second->ReadDiagnosticOptions(DiagOpts, Complain);
183 }
184
185 bool
186 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
187                                                 bool Complain) {
188   return First->ReadFileSystemOptions(FSOpts, Complain) ||
189          Second->ReadFileSystemOptions(FSOpts, Complain);
190 }
191
192 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
193     const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
194     bool Complain) {
195   return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
196                                         Complain) ||
197          Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
198                                          Complain);
199 }
200
201 bool ChainedASTReaderListener::ReadPreprocessorOptions(
202     const PreprocessorOptions &PPOpts, bool Complain,
203     std::string &SuggestedPredefines) {
204   return First->ReadPreprocessorOptions(PPOpts, Complain,
205                                         SuggestedPredefines) ||
206          Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
207 }
208
209 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
210                                            unsigned Value) {
211   First->ReadCounter(M, Value);
212   Second->ReadCounter(M, Value);
213 }
214
215 bool ChainedASTReaderListener::needsInputFileVisitation() {
216   return First->needsInputFileVisitation() ||
217          Second->needsInputFileVisitation();
218 }
219
220 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
221   return First->needsSystemInputFileVisitation() ||
222   Second->needsSystemInputFileVisitation();
223 }
224
225 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
226                                                ModuleKind Kind) {
227   First->visitModuleFile(Filename, Kind);
228   Second->visitModuleFile(Filename, Kind);
229 }
230
231 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
232                                               bool isSystem,
233                                               bool isOverridden,
234                                               bool isExplicitModule) {
235   bool Continue = false;
236   if (First->needsInputFileVisitation() &&
237       (!isSystem || First->needsSystemInputFileVisitation()))
238     Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
239                                       isExplicitModule);
240   if (Second->needsInputFileVisitation() &&
241       (!isSystem || Second->needsSystemInputFileVisitation()))
242     Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
243                                        isExplicitModule);
244   return Continue;
245 }
246
247 void ChainedASTReaderListener::readModuleFileExtension(
248        const ModuleFileExtensionMetadata &Metadata) {
249   First->readModuleFileExtension(Metadata);
250   Second->readModuleFileExtension(Metadata);
251 }
252
253 //===----------------------------------------------------------------------===//
254 // PCH validator implementation
255 //===----------------------------------------------------------------------===//
256
257 ASTReaderListener::~ASTReaderListener() = default;
258
259 /// Compare the given set of language options against an existing set of
260 /// language options.
261 ///
262 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
263 /// \param AllowCompatibleDifferences If true, differences between compatible
264 ///        language options will be permitted.
265 ///
266 /// \returns true if the languagae options mis-match, false otherwise.
267 static bool checkLanguageOptions(const LangOptions &LangOpts,
268                                  const LangOptions &ExistingLangOpts,
269                                  DiagnosticsEngine *Diags,
270                                  bool AllowCompatibleDifferences = true) {
271 #define LANGOPT(Name, Bits, Default, Description)                 \
272   if (ExistingLangOpts.Name != LangOpts.Name) {                   \
273     if (Diags)                                                    \
274       Diags->Report(diag::err_pch_langopt_mismatch)               \
275         << Description << LangOpts.Name << ExistingLangOpts.Name; \
276     return true;                                                  \
277   }
278
279 #define VALUE_LANGOPT(Name, Bits, Default, Description)   \
280   if (ExistingLangOpts.Name != LangOpts.Name) {           \
281     if (Diags)                                            \
282       Diags->Report(diag::err_pch_langopt_value_mismatch) \
283         << Description;                                   \
284     return true;                                          \
285   }
286
287 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)   \
288   if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) {  \
289     if (Diags)                                                 \
290       Diags->Report(diag::err_pch_langopt_value_mismatch)      \
291         << Description;                                        \
292     return true;                                               \
293   }
294
295 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description)  \
296   if (!AllowCompatibleDifferences)                            \
297     LANGOPT(Name, Bits, Default, Description)
298
299 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description)  \
300   if (!AllowCompatibleDifferences)                                 \
301     ENUM_LANGOPT(Name, Bits, Default, Description)
302
303 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
304   if (!AllowCompatibleDifferences)                                 \
305     VALUE_LANGOPT(Name, Bits, Default, Description)
306
307 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
308 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
309 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
310 #include "clang/Basic/LangOptions.def"
311
312   if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
313     if (Diags)
314       Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
315     return true;
316   }
317
318   if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
319     if (Diags)
320       Diags->Report(diag::err_pch_langopt_value_mismatch)
321       << "target Objective-C runtime";
322     return true;
323   }
324
325   if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
326       LangOpts.CommentOpts.BlockCommandNames) {
327     if (Diags)
328       Diags->Report(diag::err_pch_langopt_value_mismatch)
329         << "block command names";
330     return true;
331   }
332
333   // Sanitizer feature mismatches are treated as compatible differences. If
334   // compatible differences aren't allowed, we still only want to check for
335   // mismatches of non-modular sanitizers (the only ones which can affect AST
336   // generation).
337   if (!AllowCompatibleDifferences) {
338     SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
339     SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
340     SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
341     ExistingSanitizers.clear(ModularSanitizers);
342     ImportedSanitizers.clear(ModularSanitizers);
343     if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
344       const std::string Flag = "-fsanitize=";
345       if (Diags) {
346 #define SANITIZER(NAME, ID)                                                    \
347   {                                                                            \
348     bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID);         \
349     bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID);         \
350     if (InExistingModule != InImportedModule)                                  \
351       Diags->Report(diag::err_pch_targetopt_feature_mismatch)                  \
352           << InExistingModule << (Flag + NAME);                                \
353   }
354 #include "clang/Basic/Sanitizers.def"
355       }
356       return true;
357     }
358   }
359
360   return false;
361 }
362
363 /// Compare the given set of target options against an existing set of
364 /// target options.
365 ///
366 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
367 ///
368 /// \returns true if the target options mis-match, false otherwise.
369 static bool checkTargetOptions(const TargetOptions &TargetOpts,
370                                const TargetOptions &ExistingTargetOpts,
371                                DiagnosticsEngine *Diags,
372                                bool AllowCompatibleDifferences = true) {
373 #define CHECK_TARGET_OPT(Field, Name)                             \
374   if (TargetOpts.Field != ExistingTargetOpts.Field) {             \
375     if (Diags)                                                    \
376       Diags->Report(diag::err_pch_targetopt_mismatch)             \
377         << Name << TargetOpts.Field << ExistingTargetOpts.Field;  \
378     return true;                                                  \
379   }
380
381   // The triple and ABI must match exactly.
382   CHECK_TARGET_OPT(Triple, "target");
383   CHECK_TARGET_OPT(ABI, "target ABI");
384
385   // We can tolerate different CPUs in many cases, notably when one CPU
386   // supports a strict superset of another. When allowing compatible
387   // differences skip this check.
388   if (!AllowCompatibleDifferences)
389     CHECK_TARGET_OPT(CPU, "target CPU");
390
391 #undef CHECK_TARGET_OPT
392
393   // Compare feature sets.
394   SmallVector<StringRef, 4> ExistingFeatures(
395                                              ExistingTargetOpts.FeaturesAsWritten.begin(),
396                                              ExistingTargetOpts.FeaturesAsWritten.end());
397   SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
398                                          TargetOpts.FeaturesAsWritten.end());
399   llvm::sort(ExistingFeatures);
400   llvm::sort(ReadFeatures);
401
402   // We compute the set difference in both directions explicitly so that we can
403   // diagnose the differences differently.
404   SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
405   std::set_difference(
406       ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
407       ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
408   std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
409                       ExistingFeatures.begin(), ExistingFeatures.end(),
410                       std::back_inserter(UnmatchedReadFeatures));
411
412   // If we are allowing compatible differences and the read feature set is
413   // a strict subset of the existing feature set, there is nothing to diagnose.
414   if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
415     return false;
416
417   if (Diags) {
418     for (StringRef Feature : UnmatchedReadFeatures)
419       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
420           << /* is-existing-feature */ false << Feature;
421     for (StringRef Feature : UnmatchedExistingFeatures)
422       Diags->Report(diag::err_pch_targetopt_feature_mismatch)
423           << /* is-existing-feature */ true << Feature;
424   }
425
426   return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
427 }
428
429 bool
430 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
431                                   bool Complain,
432                                   bool AllowCompatibleDifferences) {
433   const LangOptions &ExistingLangOpts = PP.getLangOpts();
434   return checkLanguageOptions(LangOpts, ExistingLangOpts,
435                               Complain ? &Reader.Diags : nullptr,
436                               AllowCompatibleDifferences);
437 }
438
439 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
440                                      bool Complain,
441                                      bool AllowCompatibleDifferences) {
442   const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
443   return checkTargetOptions(TargetOpts, ExistingTargetOpts,
444                             Complain ? &Reader.Diags : nullptr,
445                             AllowCompatibleDifferences);
446 }
447
448 namespace {
449
450 using MacroDefinitionsMap =
451     llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
452 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
453
454 } // namespace
455
456 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
457                                          DiagnosticsEngine &Diags,
458                                          bool Complain) {
459   using Level = DiagnosticsEngine::Level;
460
461   // Check current mappings for new -Werror mappings, and the stored mappings
462   // for cases that were explicitly mapped to *not* be errors that are now
463   // errors because of options like -Werror.
464   DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
465
466   for (DiagnosticsEngine *MappingSource : MappingSources) {
467     for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
468       diag::kind DiagID = DiagIDMappingPair.first;
469       Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
470       if (CurLevel < DiagnosticsEngine::Error)
471         continue; // not significant
472       Level StoredLevel =
473           StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
474       if (StoredLevel < DiagnosticsEngine::Error) {
475         if (Complain)
476           Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
477               Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
478         return true;
479       }
480     }
481   }
482
483   return false;
484 }
485
486 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
487   diag::Severity Ext = Diags.getExtensionHandlingBehavior();
488   if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
489     return true;
490   return Ext >= diag::Severity::Error;
491 }
492
493 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
494                                     DiagnosticsEngine &Diags,
495                                     bool IsSystem, bool Complain) {
496   // Top-level options
497   if (IsSystem) {
498     if (Diags.getSuppressSystemWarnings())
499       return false;
500     // If -Wsystem-headers was not enabled before, be conservative
501     if (StoredDiags.getSuppressSystemWarnings()) {
502       if (Complain)
503         Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
504       return true;
505     }
506   }
507
508   if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
509     if (Complain)
510       Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
511     return true;
512   }
513
514   if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
515       !StoredDiags.getEnableAllWarnings()) {
516     if (Complain)
517       Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
518     return true;
519   }
520
521   if (isExtHandlingFromDiagsError(Diags) &&
522       !isExtHandlingFromDiagsError(StoredDiags)) {
523     if (Complain)
524       Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
525     return true;
526   }
527
528   return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
529 }
530
531 /// Return the top import module if it is implicit, nullptr otherwise.
532 static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
533                                           Preprocessor &PP) {
534   // If the original import came from a file explicitly generated by the user,
535   // don't check the diagnostic mappings.
536   // FIXME: currently this is approximated by checking whether this is not a
537   // module import of an implicitly-loaded module file.
538   // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
539   // the transitive closure of its imports, since unrelated modules cannot be
540   // imported until after this module finishes validation.
541   ModuleFile *TopImport = &*ModuleMgr.rbegin();
542   while (!TopImport->ImportedBy.empty())
543     TopImport = TopImport->ImportedBy[0];
544   if (TopImport->Kind != MK_ImplicitModule)
545     return nullptr;
546
547   StringRef ModuleName = TopImport->ModuleName;
548   assert(!ModuleName.empty() && "diagnostic options read before module name");
549
550   Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
551   assert(M && "missing module");
552   return M;
553 }
554
555 bool PCHValidator::ReadDiagnosticOptions(
556     IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
557   DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
558   IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
559   IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
560       new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
561   // This should never fail, because we would have processed these options
562   // before writing them to an ASTFile.
563   ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
564
565   ModuleManager &ModuleMgr = Reader.getModuleManager();
566   assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
567
568   Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
569   if (!TopM)
570     return false;
571
572   // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
573   // contains the union of their flags.
574   return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
575                                  Complain);
576 }
577
578 /// Collect the macro definitions provided by the given preprocessor
579 /// options.
580 static void
581 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
582                         MacroDefinitionsMap &Macros,
583                         SmallVectorImpl<StringRef> *MacroNames = nullptr) {
584   for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
585     StringRef Macro = PPOpts.Macros[I].first;
586     bool IsUndef = PPOpts.Macros[I].second;
587
588     std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
589     StringRef MacroName = MacroPair.first;
590     StringRef MacroBody = MacroPair.second;
591
592     // For an #undef'd macro, we only care about the name.
593     if (IsUndef) {
594       if (MacroNames && !Macros.count(MacroName))
595         MacroNames->push_back(MacroName);
596
597       Macros[MacroName] = std::make_pair("", true);
598       continue;
599     }
600
601     // For a #define'd macro, figure out the actual definition.
602     if (MacroName.size() == Macro.size())
603       MacroBody = "1";
604     else {
605       // Note: GCC drops anything following an end-of-line character.
606       StringRef::size_type End = MacroBody.find_first_of("\n\r");
607       MacroBody = MacroBody.substr(0, End);
608     }
609
610     if (MacroNames && !Macros.count(MacroName))
611       MacroNames->push_back(MacroName);
612     Macros[MacroName] = std::make_pair(MacroBody, false);
613   }
614 }
615
616 /// Check the preprocessor options deserialized from the control block
617 /// against the preprocessor options in an existing preprocessor.
618 ///
619 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620 /// \param Validate If true, validate preprocessor options. If false, allow
621 ///        macros defined by \p ExistingPPOpts to override those defined by
622 ///        \p PPOpts in SuggestedPredefines.
623 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
624                                      const PreprocessorOptions &ExistingPPOpts,
625                                      DiagnosticsEngine *Diags,
626                                      FileManager &FileMgr,
627                                      std::string &SuggestedPredefines,
628                                      const LangOptions &LangOpts,
629                                      bool Validate = true) {
630   // Check macro definitions.
631   MacroDefinitionsMap ASTFileMacros;
632   collectMacroDefinitions(PPOpts, ASTFileMacros);
633   MacroDefinitionsMap ExistingMacros;
634   SmallVector<StringRef, 4> ExistingMacroNames;
635   collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
636
637   for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
638     // Dig out the macro definition in the existing preprocessor options.
639     StringRef MacroName = ExistingMacroNames[I];
640     std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
641
642     // Check whether we know anything about this macro name or not.
643     llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
644         ASTFileMacros.find(MacroName);
645     if (!Validate || Known == ASTFileMacros.end()) {
646       // FIXME: Check whether this identifier was referenced anywhere in the
647       // AST file. If so, we should reject the AST file. Unfortunately, this
648       // information isn't in the control block. What shall we do about it?
649
650       if (Existing.second) {
651         SuggestedPredefines += "#undef ";
652         SuggestedPredefines += MacroName.str();
653         SuggestedPredefines += '\n';
654       } else {
655         SuggestedPredefines += "#define ";
656         SuggestedPredefines += MacroName.str();
657         SuggestedPredefines += ' ';
658         SuggestedPredefines += Existing.first.str();
659         SuggestedPredefines += '\n';
660       }
661       continue;
662     }
663
664     // If the macro was defined in one but undef'd in the other, we have a
665     // conflict.
666     if (Existing.second != Known->second.second) {
667       if (Diags) {
668         Diags->Report(diag::err_pch_macro_def_undef)
669           << MacroName << Known->second.second;
670       }
671       return true;
672     }
673
674     // If the macro was #undef'd in both, or if the macro bodies are identical,
675     // it's fine.
676     if (Existing.second || Existing.first == Known->second.first)
677       continue;
678
679     // The macro bodies differ; complain.
680     if (Diags) {
681       Diags->Report(diag::err_pch_macro_def_conflict)
682         << MacroName << Known->second.first << Existing.first;
683     }
684     return true;
685   }
686
687   // Check whether we're using predefines.
688   if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
689     if (Diags) {
690       Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
691     }
692     return true;
693   }
694
695   // Detailed record is important since it is used for the module cache hash.
696   if (LangOpts.Modules &&
697       PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
698     if (Diags) {
699       Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
700     }
701     return true;
702   }
703
704   // Compute the #include and #include_macros lines we need.
705   for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
706     StringRef File = ExistingPPOpts.Includes[I];
707
708     if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
709         !ExistingPPOpts.PCHThroughHeader.empty()) {
710       // In case the through header is an include, we must add all the includes
711       // to the predefines so the start point can be determined.
712       SuggestedPredefines += "#include \"";
713       SuggestedPredefines += File;
714       SuggestedPredefines += "\"\n";
715       continue;
716     }
717
718     if (File == ExistingPPOpts.ImplicitPCHInclude)
719       continue;
720
721     if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
722           != PPOpts.Includes.end())
723       continue;
724
725     SuggestedPredefines += "#include \"";
726     SuggestedPredefines += File;
727     SuggestedPredefines += "\"\n";
728   }
729
730   for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
731     StringRef File = ExistingPPOpts.MacroIncludes[I];
732     if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
733                   File)
734         != PPOpts.MacroIncludes.end())
735       continue;
736
737     SuggestedPredefines += "#__include_macros \"";
738     SuggestedPredefines += File;
739     SuggestedPredefines += "\"\n##\n";
740   }
741
742   return false;
743 }
744
745 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
746                                            bool Complain,
747                                            std::string &SuggestedPredefines) {
748   const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
749
750   return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
751                                   Complain? &Reader.Diags : nullptr,
752                                   PP.getFileManager(),
753                                   SuggestedPredefines,
754                                   PP.getLangOpts());
755 }
756
757 bool SimpleASTReaderListener::ReadPreprocessorOptions(
758                                   const PreprocessorOptions &PPOpts,
759                                   bool Complain,
760                                   std::string &SuggestedPredefines) {
761   return checkPreprocessorOptions(PPOpts,
762                                   PP.getPreprocessorOpts(),
763                                   nullptr,
764                                   PP.getFileManager(),
765                                   SuggestedPredefines,
766                                   PP.getLangOpts(),
767                                   false);
768 }
769
770 /// Check the header search options deserialized from the control block
771 /// against the header search options in an existing preprocessor.
772 ///
773 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
774 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
775                                      StringRef SpecificModuleCachePath,
776                                      StringRef ExistingModuleCachePath,
777                                      DiagnosticsEngine *Diags,
778                                      const LangOptions &LangOpts) {
779   if (LangOpts.Modules) {
780     if (SpecificModuleCachePath != ExistingModuleCachePath) {
781       if (Diags)
782         Diags->Report(diag::err_pch_modulecache_mismatch)
783           << SpecificModuleCachePath << ExistingModuleCachePath;
784       return true;
785     }
786   }
787
788   return false;
789 }
790
791 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
792                                            StringRef SpecificModuleCachePath,
793                                            bool Complain) {
794   return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
795                                   PP.getHeaderSearchInfo().getModuleCachePath(),
796                                   Complain ? &Reader.Diags : nullptr,
797                                   PP.getLangOpts());
798 }
799
800 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
801   PP.setCounterValue(Value);
802 }
803
804 //===----------------------------------------------------------------------===//
805 // AST reader implementation
806 //===----------------------------------------------------------------------===//
807
808 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
809                                            bool TakeOwnership) {
810   DeserializationListener = Listener;
811   OwnsDeserializationListener = TakeOwnership;
812 }
813
814 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
815   return serialization::ComputeHash(Sel);
816 }
817
818 std::pair<unsigned, unsigned>
819 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
820   using namespace llvm::support;
821
822   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
823   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
824   return std::make_pair(KeyLen, DataLen);
825 }
826
827 ASTSelectorLookupTrait::internal_key_type
828 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
829   using namespace llvm::support;
830
831   SelectorTable &SelTable = Reader.getContext().Selectors;
832   unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
833   IdentifierInfo *FirstII = Reader.getLocalIdentifier(
834       F, endian::readNext<uint32_t, little, unaligned>(d));
835   if (N == 0)
836     return SelTable.getNullarySelector(FirstII);
837   else if (N == 1)
838     return SelTable.getUnarySelector(FirstII);
839
840   SmallVector<IdentifierInfo *, 16> Args;
841   Args.push_back(FirstII);
842   for (unsigned I = 1; I != N; ++I)
843     Args.push_back(Reader.getLocalIdentifier(
844         F, endian::readNext<uint32_t, little, unaligned>(d)));
845
846   return SelTable.getSelector(N, Args.data());
847 }
848
849 ASTSelectorLookupTrait::data_type
850 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
851                                  unsigned DataLen) {
852   using namespace llvm::support;
853
854   data_type Result;
855
856   Result.ID = Reader.getGlobalSelectorID(
857       F, endian::readNext<uint32_t, little, unaligned>(d));
858   unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
859   unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
860   Result.InstanceBits = FullInstanceBits & 0x3;
861   Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
862   Result.FactoryBits = FullFactoryBits & 0x3;
863   Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
864   unsigned NumInstanceMethods = FullInstanceBits >> 3;
865   unsigned NumFactoryMethods = FullFactoryBits >> 3;
866
867   // Load instance methods
868   for (unsigned I = 0; I != NumInstanceMethods; ++I) {
869     if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
870             F, endian::readNext<uint32_t, little, unaligned>(d)))
871       Result.Instance.push_back(Method);
872   }
873
874   // Load factory methods
875   for (unsigned I = 0; I != NumFactoryMethods; ++I) {
876     if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
877             F, endian::readNext<uint32_t, little, unaligned>(d)))
878       Result.Factory.push_back(Method);
879   }
880
881   return Result;
882 }
883
884 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
885   return llvm::djbHash(a);
886 }
887
888 std::pair<unsigned, unsigned>
889 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
890   using namespace llvm::support;
891
892   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
893   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
894   return std::make_pair(KeyLen, DataLen);
895 }
896
897 ASTIdentifierLookupTraitBase::internal_key_type
898 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
899   assert(n >= 2 && d[n-1] == '\0');
900   return StringRef((const char*) d, n-1);
901 }
902
903 /// Whether the given identifier is "interesting".
904 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
905                                     bool IsModule) {
906   return II.hadMacroDefinition() ||
907          II.isPoisoned() ||
908          (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
909          II.hasRevertedTokenIDToIdentifier() ||
910          (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
911           II.getFETokenInfo());
912 }
913
914 static bool readBit(unsigned &Bits) {
915   bool Value = Bits & 0x1;
916   Bits >>= 1;
917   return Value;
918 }
919
920 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
921   using namespace llvm::support;
922
923   unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
924   return Reader.getGlobalIdentifierID(F, RawID >> 1);
925 }
926
927 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
928   if (!II.isFromAST()) {
929     II.setIsFromAST();
930     bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
931     if (isInterestingIdentifier(Reader, II, IsModule))
932       II.setChangedSinceDeserialization();
933   }
934 }
935
936 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
937                                                    const unsigned char* d,
938                                                    unsigned DataLen) {
939   using namespace llvm::support;
940
941   unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
942   bool IsInteresting = RawID & 0x01;
943
944   // Wipe out the "is interesting" bit.
945   RawID = RawID >> 1;
946
947   // Build the IdentifierInfo and link the identifier ID with it.
948   IdentifierInfo *II = KnownII;
949   if (!II) {
950     II = &Reader.getIdentifierTable().getOwn(k);
951     KnownII = II;
952   }
953   markIdentifierFromAST(Reader, *II);
954   Reader.markIdentifierUpToDate(II);
955
956   IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
957   if (!IsInteresting) {
958     // For uninteresting identifiers, there's nothing else to do. Just notify
959     // the reader that we've finished loading this identifier.
960     Reader.SetIdentifierInfo(ID, II);
961     return II;
962   }
963
964   unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
965   unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
966   bool CPlusPlusOperatorKeyword = readBit(Bits);
967   bool HasRevertedTokenIDToIdentifier = readBit(Bits);
968   bool HasRevertedBuiltin = readBit(Bits);
969   bool Poisoned = readBit(Bits);
970   bool ExtensionToken = readBit(Bits);
971   bool HadMacroDefinition = readBit(Bits);
972
973   assert(Bits == 0 && "Extra bits in the identifier?");
974   DataLen -= 8;
975
976   // Set or check the various bits in the IdentifierInfo structure.
977   // Token IDs are read-only.
978   if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
979     II->revertTokenIDToIdentifier();
980   if (!F.isModule())
981     II->setObjCOrBuiltinID(ObjCOrBuiltinID);
982   else if (HasRevertedBuiltin && II->getBuiltinID()) {
983     II->revertBuiltin();
984     assert((II->hasRevertedBuiltin() ||
985             II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
986            "Incorrect ObjC keyword or builtin ID");
987   }
988   assert(II->isExtensionToken() == ExtensionToken &&
989          "Incorrect extension token flag");
990   (void)ExtensionToken;
991   if (Poisoned)
992     II->setIsPoisoned(true);
993   assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
994          "Incorrect C++ operator keyword flag");
995   (void)CPlusPlusOperatorKeyword;
996
997   // If this identifier is a macro, deserialize the macro
998   // definition.
999   if (HadMacroDefinition) {
1000     uint32_t MacroDirectivesOffset =
1001         endian::readNext<uint32_t, little, unaligned>(d);
1002     DataLen -= 4;
1003
1004     Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1005   }
1006
1007   Reader.SetIdentifierInfo(ID, II);
1008
1009   // Read all of the declarations visible at global scope with this
1010   // name.
1011   if (DataLen > 0) {
1012     SmallVector<uint32_t, 4> DeclIDs;
1013     for (; DataLen > 0; DataLen -= 4)
1014       DeclIDs.push_back(Reader.getGlobalDeclID(
1015           F, endian::readNext<uint32_t, little, unaligned>(d)));
1016     Reader.SetGloballyVisibleDecls(II, DeclIDs);
1017   }
1018
1019   return II;
1020 }
1021
1022 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1023     : Kind(Name.getNameKind()) {
1024   switch (Kind) {
1025   case DeclarationName::Identifier:
1026     Data = (uint64_t)Name.getAsIdentifierInfo();
1027     break;
1028   case DeclarationName::ObjCZeroArgSelector:
1029   case DeclarationName::ObjCOneArgSelector:
1030   case DeclarationName::ObjCMultiArgSelector:
1031     Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1032     break;
1033   case DeclarationName::CXXOperatorName:
1034     Data = Name.getCXXOverloadedOperator();
1035     break;
1036   case DeclarationName::CXXLiteralOperatorName:
1037     Data = (uint64_t)Name.getCXXLiteralIdentifier();
1038     break;
1039   case DeclarationName::CXXDeductionGuideName:
1040     Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1041                ->getDeclName().getAsIdentifierInfo();
1042     break;
1043   case DeclarationName::CXXConstructorName:
1044   case DeclarationName::CXXDestructorName:
1045   case DeclarationName::CXXConversionFunctionName:
1046   case DeclarationName::CXXUsingDirective:
1047     Data = 0;
1048     break;
1049   }
1050 }
1051
1052 unsigned DeclarationNameKey::getHash() const {
1053   llvm::FoldingSetNodeID ID;
1054   ID.AddInteger(Kind);
1055
1056   switch (Kind) {
1057   case DeclarationName::Identifier:
1058   case DeclarationName::CXXLiteralOperatorName:
1059   case DeclarationName::CXXDeductionGuideName:
1060     ID.AddString(((IdentifierInfo*)Data)->getName());
1061     break;
1062   case DeclarationName::ObjCZeroArgSelector:
1063   case DeclarationName::ObjCOneArgSelector:
1064   case DeclarationName::ObjCMultiArgSelector:
1065     ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1066     break;
1067   case DeclarationName::CXXOperatorName:
1068     ID.AddInteger((OverloadedOperatorKind)Data);
1069     break;
1070   case DeclarationName::CXXConstructorName:
1071   case DeclarationName::CXXDestructorName:
1072   case DeclarationName::CXXConversionFunctionName:
1073   case DeclarationName::CXXUsingDirective:
1074     break;
1075   }
1076
1077   return ID.ComputeHash();
1078 }
1079
1080 ModuleFile *
1081 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1082   using namespace llvm::support;
1083
1084   uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1085   return Reader.getLocalModuleFile(F, ModuleFileID);
1086 }
1087
1088 std::pair<unsigned, unsigned>
1089 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1090   using namespace llvm::support;
1091
1092   unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1093   unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1094   return std::make_pair(KeyLen, DataLen);
1095 }
1096
1097 ASTDeclContextNameLookupTrait::internal_key_type
1098 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1099   using namespace llvm::support;
1100
1101   auto Kind = (DeclarationName::NameKind)*d++;
1102   uint64_t Data;
1103   switch (Kind) {
1104   case DeclarationName::Identifier:
1105   case DeclarationName::CXXLiteralOperatorName:
1106   case DeclarationName::CXXDeductionGuideName:
1107     Data = (uint64_t)Reader.getLocalIdentifier(
1108         F, endian::readNext<uint32_t, little, unaligned>(d));
1109     break;
1110   case DeclarationName::ObjCZeroArgSelector:
1111   case DeclarationName::ObjCOneArgSelector:
1112   case DeclarationName::ObjCMultiArgSelector:
1113     Data =
1114         (uint64_t)Reader.getLocalSelector(
1115                              F, endian::readNext<uint32_t, little, unaligned>(
1116                                     d)).getAsOpaquePtr();
1117     break;
1118   case DeclarationName::CXXOperatorName:
1119     Data = *d++; // OverloadedOperatorKind
1120     break;
1121   case DeclarationName::CXXConstructorName:
1122   case DeclarationName::CXXDestructorName:
1123   case DeclarationName::CXXConversionFunctionName:
1124   case DeclarationName::CXXUsingDirective:
1125     Data = 0;
1126     break;
1127   }
1128
1129   return DeclarationNameKey(Kind, Data);
1130 }
1131
1132 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1133                                                  const unsigned char *d,
1134                                                  unsigned DataLen,
1135                                                  data_type_builder &Val) {
1136   using namespace llvm::support;
1137
1138   for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1139     uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1140     Val.insert(Reader.getGlobalDeclID(F, LocalID));
1141   }
1142 }
1143
1144 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1145                                               BitstreamCursor &Cursor,
1146                                               uint64_t Offset,
1147                                               DeclContext *DC) {
1148   assert(Offset != 0);
1149
1150   SavedStreamPosition SavedPosition(Cursor);
1151   if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1152     Error(std::move(Err));
1153     return true;
1154   }
1155
1156   RecordData Record;
1157   StringRef Blob;
1158   Expected<unsigned> MaybeCode = Cursor.ReadCode();
1159   if (!MaybeCode) {
1160     Error(MaybeCode.takeError());
1161     return true;
1162   }
1163   unsigned Code = MaybeCode.get();
1164
1165   Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1166   if (!MaybeRecCode) {
1167     Error(MaybeRecCode.takeError());
1168     return true;
1169   }
1170   unsigned RecCode = MaybeRecCode.get();
1171   if (RecCode != DECL_CONTEXT_LEXICAL) {
1172     Error("Expected lexical block");
1173     return true;
1174   }
1175
1176   assert(!isa<TranslationUnitDecl>(DC) &&
1177          "expected a TU_UPDATE_LEXICAL record for TU");
1178   // If we are handling a C++ class template instantiation, we can see multiple
1179   // lexical updates for the same record. It's important that we select only one
1180   // of them, so that field numbering works properly. Just pick the first one we
1181   // see.
1182   auto &Lex = LexicalDecls[DC];
1183   if (!Lex.first) {
1184     Lex = std::make_pair(
1185         &M, llvm::makeArrayRef(
1186                 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1187                     Blob.data()),
1188                 Blob.size() / 4));
1189   }
1190   DC->setHasExternalLexicalStorage(true);
1191   return false;
1192 }
1193
1194 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1195                                               BitstreamCursor &Cursor,
1196                                               uint64_t Offset,
1197                                               DeclID ID) {
1198   assert(Offset != 0);
1199
1200   SavedStreamPosition SavedPosition(Cursor);
1201   if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1202     Error(std::move(Err));
1203     return true;
1204   }
1205
1206   RecordData Record;
1207   StringRef Blob;
1208   Expected<unsigned> MaybeCode = Cursor.ReadCode();
1209   if (!MaybeCode) {
1210     Error(MaybeCode.takeError());
1211     return true;
1212   }
1213   unsigned Code = MaybeCode.get();
1214
1215   Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1216   if (!MaybeRecCode) {
1217     Error(MaybeRecCode.takeError());
1218     return true;
1219   }
1220   unsigned RecCode = MaybeRecCode.get();
1221   if (RecCode != DECL_CONTEXT_VISIBLE) {
1222     Error("Expected visible lookup table block");
1223     return true;
1224   }
1225
1226   // We can't safely determine the primary context yet, so delay attaching the
1227   // lookup table until we're done with recursive deserialization.
1228   auto *Data = (const unsigned char*)Blob.data();
1229   PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1230   return false;
1231 }
1232
1233 void ASTReader::Error(StringRef Msg) const {
1234   Error(diag::err_fe_pch_malformed, Msg);
1235   if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1236       !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1237     Diag(diag::note_module_cache_path)
1238       << PP.getHeaderSearchInfo().getModuleCachePath();
1239   }
1240 }
1241
1242 void ASTReader::Error(unsigned DiagID,
1243                       StringRef Arg1, StringRef Arg2) const {
1244   if (Diags.isDiagnosticInFlight())
1245     Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1246   else
1247     Diag(DiagID) << Arg1 << Arg2;
1248 }
1249
1250 void ASTReader::Error(llvm::Error &&Err) const {
1251   Error(toString(std::move(Err)));
1252 }
1253
1254 //===----------------------------------------------------------------------===//
1255 // Source Manager Deserialization
1256 //===----------------------------------------------------------------------===//
1257
1258 /// Read the line table in the source manager block.
1259 /// \returns true if there was an error.
1260 bool ASTReader::ParseLineTable(ModuleFile &F,
1261                                const RecordData &Record) {
1262   unsigned Idx = 0;
1263   LineTableInfo &LineTable = SourceMgr.getLineTable();
1264
1265   // Parse the file names
1266   std::map<int, int> FileIDs;
1267   FileIDs[-1] = -1; // For unspecified filenames.
1268   for (unsigned I = 0; Record[Idx]; ++I) {
1269     // Extract the file name
1270     auto Filename = ReadPath(F, Record, Idx);
1271     FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1272   }
1273   ++Idx;
1274
1275   // Parse the line entries
1276   std::vector<LineEntry> Entries;
1277   while (Idx < Record.size()) {
1278     int FID = Record[Idx++];
1279     assert(FID >= 0 && "Serialized line entries for non-local file.");
1280     // Remap FileID from 1-based old view.
1281     FID += F.SLocEntryBaseID - 1;
1282
1283     // Extract the line entries
1284     unsigned NumEntries = Record[Idx++];
1285     assert(NumEntries && "no line entries for file ID");
1286     Entries.clear();
1287     Entries.reserve(NumEntries);
1288     for (unsigned I = 0; I != NumEntries; ++I) {
1289       unsigned FileOffset = Record[Idx++];
1290       unsigned LineNo = Record[Idx++];
1291       int FilenameID = FileIDs[Record[Idx++]];
1292       SrcMgr::CharacteristicKind FileKind
1293         = (SrcMgr::CharacteristicKind)Record[Idx++];
1294       unsigned IncludeOffset = Record[Idx++];
1295       Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1296                                        FileKind, IncludeOffset));
1297     }
1298     LineTable.AddEntry(FileID::get(FID), Entries);
1299   }
1300
1301   return false;
1302 }
1303
1304 /// Read a source manager block
1305 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1306   using namespace SrcMgr;
1307
1308   BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1309
1310   // Set the source-location entry cursor to the current position in
1311   // the stream. This cursor will be used to read the contents of the
1312   // source manager block initially, and then lazily read
1313   // source-location entries as needed.
1314   SLocEntryCursor = F.Stream;
1315
1316   // The stream itself is going to skip over the source manager block.
1317   if (llvm::Error Err = F.Stream.SkipBlock()) {
1318     Error(std::move(Err));
1319     return true;
1320   }
1321
1322   // Enter the source manager block.
1323   if (llvm::Error Err =
1324           SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1325     Error(std::move(Err));
1326     return true;
1327   }
1328
1329   RecordData Record;
1330   while (true) {
1331     Expected<llvm::BitstreamEntry> MaybeE =
1332         SLocEntryCursor.advanceSkippingSubblocks();
1333     if (!MaybeE) {
1334       Error(MaybeE.takeError());
1335       return true;
1336     }
1337     llvm::BitstreamEntry E = MaybeE.get();
1338
1339     switch (E.Kind) {
1340     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1341     case llvm::BitstreamEntry::Error:
1342       Error("malformed block record in AST file");
1343       return true;
1344     case llvm::BitstreamEntry::EndBlock:
1345       return false;
1346     case llvm::BitstreamEntry::Record:
1347       // The interesting case.
1348       break;
1349     }
1350
1351     // Read a record.
1352     Record.clear();
1353     StringRef Blob;
1354     Expected<unsigned> MaybeRecord =
1355         SLocEntryCursor.readRecord(E.ID, Record, &Blob);
1356     if (!MaybeRecord) {
1357       Error(MaybeRecord.takeError());
1358       return true;
1359     }
1360     switch (MaybeRecord.get()) {
1361     default:  // Default behavior: ignore.
1362       break;
1363
1364     case SM_SLOC_FILE_ENTRY:
1365     case SM_SLOC_BUFFER_ENTRY:
1366     case SM_SLOC_EXPANSION_ENTRY:
1367       // Once we hit one of the source location entries, we're done.
1368       return false;
1369     }
1370   }
1371 }
1372
1373 /// If a header file is not found at the path that we expect it to be
1374 /// and the PCH file was moved from its original location, try to resolve the
1375 /// file by assuming that header+PCH were moved together and the header is in
1376 /// the same place relative to the PCH.
1377 static std::string
1378 resolveFileRelativeToOriginalDir(const std::string &Filename,
1379                                  const std::string &OriginalDir,
1380                                  const std::string &CurrDir) {
1381   assert(OriginalDir != CurrDir &&
1382          "No point trying to resolve the file if the PCH dir didn't change");
1383
1384   using namespace llvm::sys;
1385
1386   SmallString<128> filePath(Filename);
1387   fs::make_absolute(filePath);
1388   assert(path::is_absolute(OriginalDir));
1389   SmallString<128> currPCHPath(CurrDir);
1390
1391   path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1392                        fileDirE = path::end(path::parent_path(filePath));
1393   path::const_iterator origDirI = path::begin(OriginalDir),
1394                        origDirE = path::end(OriginalDir);
1395   // Skip the common path components from filePath and OriginalDir.
1396   while (fileDirI != fileDirE && origDirI != origDirE &&
1397          *fileDirI == *origDirI) {
1398     ++fileDirI;
1399     ++origDirI;
1400   }
1401   for (; origDirI != origDirE; ++origDirI)
1402     path::append(currPCHPath, "..");
1403   path::append(currPCHPath, fileDirI, fileDirE);
1404   path::append(currPCHPath, path::filename(Filename));
1405   return currPCHPath.str();
1406 }
1407
1408 bool ASTReader::ReadSLocEntry(int ID) {
1409   if (ID == 0)
1410     return false;
1411
1412   if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1413     Error("source location entry ID out-of-range for AST file");
1414     return true;
1415   }
1416
1417   // Local helper to read the (possibly-compressed) buffer data following the
1418   // entry record.
1419   auto ReadBuffer = [this](
1420       BitstreamCursor &SLocEntryCursor,
1421       StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1422     RecordData Record;
1423     StringRef Blob;
1424     Expected<unsigned> MaybeCode = SLocEntryCursor.ReadCode();
1425     if (!MaybeCode) {
1426       Error(MaybeCode.takeError());
1427       return nullptr;
1428     }
1429     unsigned Code = MaybeCode.get();
1430
1431     Expected<unsigned> MaybeRecCode =
1432         SLocEntryCursor.readRecord(Code, Record, &Blob);
1433     if (!MaybeRecCode) {
1434       Error(MaybeRecCode.takeError());
1435       return nullptr;
1436     }
1437     unsigned RecCode = MaybeRecCode.get();
1438
1439     if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1440       if (!llvm::zlib::isAvailable()) {
1441         Error("zlib is not available");
1442         return nullptr;
1443       }
1444       SmallString<0> Uncompressed;
1445       if (llvm::Error E =
1446               llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1447         Error("could not decompress embedded file contents: " +
1448               llvm::toString(std::move(E)));
1449         return nullptr;
1450       }
1451       return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1452     } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1453       return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1454     } else {
1455       Error("AST record has invalid code");
1456       return nullptr;
1457     }
1458   };
1459
1460   ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1461   if (llvm::Error Err = F->SLocEntryCursor.JumpToBit(
1462           F->SLocEntryOffsets[ID - F->SLocEntryBaseID])) {
1463     Error(std::move(Err));
1464     return true;
1465   }
1466
1467   BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1468   unsigned BaseOffset = F->SLocEntryBaseOffset;
1469
1470   ++NumSLocEntriesRead;
1471   Expected<llvm::BitstreamEntry> MaybeEntry = SLocEntryCursor.advance();
1472   if (!MaybeEntry) {
1473     Error(MaybeEntry.takeError());
1474     return true;
1475   }
1476   llvm::BitstreamEntry Entry = MaybeEntry.get();
1477
1478   if (Entry.Kind != llvm::BitstreamEntry::Record) {
1479     Error("incorrectly-formatted source location entry in AST file");
1480     return true;
1481   }
1482
1483   RecordData Record;
1484   StringRef Blob;
1485   Expected<unsigned> MaybeSLOC =
1486       SLocEntryCursor.readRecord(Entry.ID, Record, &Blob);
1487   if (!MaybeSLOC) {
1488     Error(MaybeSLOC.takeError());
1489     return true;
1490   }
1491   switch (MaybeSLOC.get()) {
1492   default:
1493     Error("incorrectly-formatted source location entry in AST file");
1494     return true;
1495
1496   case SM_SLOC_FILE_ENTRY: {
1497     // We will detect whether a file changed and return 'Failure' for it, but
1498     // we will also try to fail gracefully by setting up the SLocEntry.
1499     unsigned InputID = Record[4];
1500     InputFile IF = getInputFile(*F, InputID);
1501     const FileEntry *File = IF.getFile();
1502     bool OverriddenBuffer = IF.isOverridden();
1503
1504     // Note that we only check if a File was returned. If it was out-of-date
1505     // we have complained but we will continue creating a FileID to recover
1506     // gracefully.
1507     if (!File)
1508       return true;
1509
1510     SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1511     if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1512       // This is the module's main file.
1513       IncludeLoc = getImportLocation(F);
1514     }
1515     SrcMgr::CharacteristicKind
1516       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1517     FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1518                                         ID, BaseOffset + Record[0]);
1519     SrcMgr::FileInfo &FileInfo =
1520           const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1521     FileInfo.NumCreatedFIDs = Record[5];
1522     if (Record[3])
1523       FileInfo.setHasLineDirectives();
1524
1525     const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1526     unsigned NumFileDecls = Record[7];
1527     if (NumFileDecls && ContextObj) {
1528       assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1529       FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1530                                                              NumFileDecls));
1531     }
1532
1533     const SrcMgr::ContentCache *ContentCache
1534       = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1535     if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1536         ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1537         !ContentCache->getRawBuffer()) {
1538       auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1539       if (!Buffer)
1540         return true;
1541       SourceMgr.overrideFileContents(File, std::move(Buffer));
1542     }
1543
1544     break;
1545   }
1546
1547   case SM_SLOC_BUFFER_ENTRY: {
1548     const char *Name = Blob.data();
1549     unsigned Offset = Record[0];
1550     SrcMgr::CharacteristicKind
1551       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1552     SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1553     if (IncludeLoc.isInvalid() && F->isModule()) {
1554       IncludeLoc = getImportLocation(F);
1555     }
1556
1557     auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1558     if (!Buffer)
1559       return true;
1560     SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1561                            BaseOffset + Offset, IncludeLoc);
1562     break;
1563   }
1564
1565   case SM_SLOC_EXPANSION_ENTRY: {
1566     SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1567     SourceMgr.createExpansionLoc(SpellingLoc,
1568                                      ReadSourceLocation(*F, Record[2]),
1569                                      ReadSourceLocation(*F, Record[3]),
1570                                      Record[5],
1571                                      Record[4],
1572                                      ID,
1573                                      BaseOffset + Record[0]);
1574     break;
1575   }
1576   }
1577
1578   return false;
1579 }
1580
1581 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1582   if (ID == 0)
1583     return std::make_pair(SourceLocation(), "");
1584
1585   if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1586     Error("source location entry ID out-of-range for AST file");
1587     return std::make_pair(SourceLocation(), "");
1588   }
1589
1590   // Find which module file this entry lands in.
1591   ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1592   if (!M->isModule())
1593     return std::make_pair(SourceLocation(), "");
1594
1595   // FIXME: Can we map this down to a particular submodule? That would be
1596   // ideal.
1597   return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1598 }
1599
1600 /// Find the location where the module F is imported.
1601 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1602   if (F->ImportLoc.isValid())
1603     return F->ImportLoc;
1604
1605   // Otherwise we have a PCH. It's considered to be "imported" at the first
1606   // location of its includer.
1607   if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1608     // Main file is the importer.
1609     assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1610     return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1611   }
1612   return F->ImportedBy[0]->FirstLoc;
1613 }
1614
1615 /// Enter a subblock of the specified BlockID with the specified cursor. Read
1616 /// the abbreviations that are at the top of the block and then leave the cursor
1617 /// pointing into the block.
1618 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1619   if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
1620     // FIXME this drops errors on the floor.
1621     consumeError(std::move(Err));
1622     return true;
1623   }
1624
1625   while (true) {
1626     uint64_t Offset = Cursor.GetCurrentBitNo();
1627     Expected<unsigned> MaybeCode = Cursor.ReadCode();
1628     if (!MaybeCode) {
1629       // FIXME this drops errors on the floor.
1630       consumeError(MaybeCode.takeError());
1631       return true;
1632     }
1633     unsigned Code = MaybeCode.get();
1634
1635     // We expect all abbrevs to be at the start of the block.
1636     if (Code != llvm::bitc::DEFINE_ABBREV) {
1637       if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1638         // FIXME this drops errors on the floor.
1639         consumeError(std::move(Err));
1640         return true;
1641       }
1642       return false;
1643     }
1644     if (llvm::Error Err = Cursor.ReadAbbrevRecord()) {
1645       // FIXME this drops errors on the floor.
1646       consumeError(std::move(Err));
1647       return true;
1648     }
1649   }
1650 }
1651
1652 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1653                            unsigned &Idx) {
1654   Token Tok;
1655   Tok.startToken();
1656   Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1657   Tok.setLength(Record[Idx++]);
1658   if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1659     Tok.setIdentifierInfo(II);
1660   Tok.setKind((tok::TokenKind)Record[Idx++]);
1661   Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1662   return Tok;
1663 }
1664
1665 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1666   BitstreamCursor &Stream = F.MacroCursor;
1667
1668   // Keep track of where we are in the stream, then jump back there
1669   // after reading this macro.
1670   SavedStreamPosition SavedPosition(Stream);
1671
1672   if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1673     // FIXME this drops errors on the floor.
1674     consumeError(std::move(Err));
1675     return nullptr;
1676   }
1677   RecordData Record;
1678   SmallVector<IdentifierInfo*, 16> MacroParams;
1679   MacroInfo *Macro = nullptr;
1680
1681   while (true) {
1682     // Advance to the next record, but if we get to the end of the block, don't
1683     // pop it (removing all the abbreviations from the cursor) since we want to
1684     // be able to reseek within the block and read entries.
1685     unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1686     Expected<llvm::BitstreamEntry> MaybeEntry =
1687         Stream.advanceSkippingSubblocks(Flags);
1688     if (!MaybeEntry) {
1689       Error(MaybeEntry.takeError());
1690       return Macro;
1691     }
1692     llvm::BitstreamEntry Entry = MaybeEntry.get();
1693
1694     switch (Entry.Kind) {
1695     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1696     case llvm::BitstreamEntry::Error:
1697       Error("malformed block record in AST file");
1698       return Macro;
1699     case llvm::BitstreamEntry::EndBlock:
1700       return Macro;
1701     case llvm::BitstreamEntry::Record:
1702       // The interesting case.
1703       break;
1704     }
1705
1706     // Read a record.
1707     Record.clear();
1708     PreprocessorRecordTypes RecType;
1709     if (Expected<unsigned> MaybeRecType = Stream.readRecord(Entry.ID, Record))
1710       RecType = (PreprocessorRecordTypes)MaybeRecType.get();
1711     else {
1712       Error(MaybeRecType.takeError());
1713       return Macro;
1714     }
1715     switch (RecType) {
1716     case PP_MODULE_MACRO:
1717     case PP_MACRO_DIRECTIVE_HISTORY:
1718       return Macro;
1719
1720     case PP_MACRO_OBJECT_LIKE:
1721     case PP_MACRO_FUNCTION_LIKE: {
1722       // If we already have a macro, that means that we've hit the end
1723       // of the definition of the macro we were looking for. We're
1724       // done.
1725       if (Macro)
1726         return Macro;
1727
1728       unsigned NextIndex = 1; // Skip identifier ID.
1729       SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1730       MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1731       MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1732       MI->setIsUsed(Record[NextIndex++]);
1733       MI->setUsedForHeaderGuard(Record[NextIndex++]);
1734
1735       if (RecType == PP_MACRO_FUNCTION_LIKE) {
1736         // Decode function-like macro info.
1737         bool isC99VarArgs = Record[NextIndex++];
1738         bool isGNUVarArgs = Record[NextIndex++];
1739         bool hasCommaPasting = Record[NextIndex++];
1740         MacroParams.clear();
1741         unsigned NumArgs = Record[NextIndex++];
1742         for (unsigned i = 0; i != NumArgs; ++i)
1743           MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1744
1745         // Install function-like macro info.
1746         MI->setIsFunctionLike();
1747         if (isC99VarArgs) MI->setIsC99Varargs();
1748         if (isGNUVarArgs) MI->setIsGNUVarargs();
1749         if (hasCommaPasting) MI->setHasCommaPasting();
1750         MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1751       }
1752
1753       // Remember that we saw this macro last so that we add the tokens that
1754       // form its body to it.
1755       Macro = MI;
1756
1757       if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1758           Record[NextIndex]) {
1759         // We have a macro definition. Register the association
1760         PreprocessedEntityID
1761             GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1762         PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1763         PreprocessingRecord::PPEntityID PPID =
1764             PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1765         MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1766             PPRec.getPreprocessedEntity(PPID));
1767         if (PPDef)
1768           PPRec.RegisterMacroDefinition(Macro, PPDef);
1769       }
1770
1771       ++NumMacrosRead;
1772       break;
1773     }
1774
1775     case PP_TOKEN: {
1776       // If we see a TOKEN before a PP_MACRO_*, then the file is
1777       // erroneous, just pretend we didn't see this.
1778       if (!Macro) break;
1779
1780       unsigned Idx = 0;
1781       Token Tok = ReadToken(F, Record, Idx);
1782       Macro->AddTokenToBody(Tok);
1783       break;
1784     }
1785     }
1786   }
1787 }
1788
1789 PreprocessedEntityID
1790 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1791                                          unsigned LocalID) const {
1792   if (!M.ModuleOffsetMap.empty())
1793     ReadModuleOffsetMap(M);
1794
1795   ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1796     I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1797   assert(I != M.PreprocessedEntityRemap.end()
1798          && "Invalid index into preprocessed entity index remap");
1799
1800   return LocalID + I->second;
1801 }
1802
1803 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1804   return llvm::hash_combine(ikey.Size, ikey.ModTime);
1805 }
1806
1807 HeaderFileInfoTrait::internal_key_type
1808 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1809   internal_key_type ikey = {FE->getSize(),
1810                             M.HasTimestamps ? FE->getModificationTime() : 0,
1811                             FE->getName(), /*Imported*/ false};
1812   return ikey;
1813 }
1814
1815 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1816   if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1817     return false;
1818
1819   if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1820     return true;
1821
1822   // Determine whether the actual files are equivalent.
1823   FileManager &FileMgr = Reader.getFileManager();
1824   auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1825     if (!Key.Imported) {
1826       if (auto File = FileMgr.getFile(Key.Filename))
1827         return *File;
1828       return nullptr;
1829     }
1830
1831     std::string Resolved = Key.Filename;
1832     Reader.ResolveImportedPath(M, Resolved);
1833     if (auto File = FileMgr.getFile(Resolved))
1834       return *File;
1835     return nullptr;
1836   };
1837
1838   const FileEntry *FEA = GetFile(a);
1839   const FileEntry *FEB = GetFile(b);
1840   return FEA && FEA == FEB;
1841 }
1842
1843 std::pair<unsigned, unsigned>
1844 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1845   using namespace llvm::support;
1846
1847   unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1848   unsigned DataLen = (unsigned) *d++;
1849   return std::make_pair(KeyLen, DataLen);
1850 }
1851
1852 HeaderFileInfoTrait::internal_key_type
1853 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1854   using namespace llvm::support;
1855
1856   internal_key_type ikey;
1857   ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1858   ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1859   ikey.Filename = (const char *)d;
1860   ikey.Imported = true;
1861   return ikey;
1862 }
1863
1864 HeaderFileInfoTrait::data_type
1865 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1866                               unsigned DataLen) {
1867   using namespace llvm::support;
1868
1869   const unsigned char *End = d + DataLen;
1870   HeaderFileInfo HFI;
1871   unsigned Flags = *d++;
1872   // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1873   HFI.isImport |= (Flags >> 5) & 0x01;
1874   HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1875   HFI.DirInfo = (Flags >> 1) & 0x07;
1876   HFI.IndexHeaderMapHeader = Flags & 0x01;
1877   // FIXME: Find a better way to handle this. Maybe just store a
1878   // "has been included" flag?
1879   HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1880                              HFI.NumIncludes);
1881   HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1882       M, endian::readNext<uint32_t, little, unaligned>(d));
1883   if (unsigned FrameworkOffset =
1884           endian::readNext<uint32_t, little, unaligned>(d)) {
1885     // The framework offset is 1 greater than the actual offset,
1886     // since 0 is used as an indicator for "no framework name".
1887     StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1888     HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1889   }
1890
1891   assert((End - d) % 4 == 0 &&
1892          "Wrong data length in HeaderFileInfo deserialization");
1893   while (d != End) {
1894     uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1895     auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1896     LocalSMID >>= 2;
1897
1898     // This header is part of a module. Associate it with the module to enable
1899     // implicit module import.
1900     SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1901     Module *Mod = Reader.getSubmodule(GlobalSMID);
1902     FileManager &FileMgr = Reader.getFileManager();
1903     ModuleMap &ModMap =
1904         Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1905
1906     std::string Filename = key.Filename;
1907     if (key.Imported)
1908       Reader.ResolveImportedPath(M, Filename);
1909     // FIXME: This is not always the right filename-as-written, but we're not
1910     // going to use this information to rebuild the module, so it doesn't make
1911     // a lot of difference.
1912     Module::Header H = { key.Filename, *FileMgr.getFile(Filename) };
1913     ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1914     HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1915   }
1916
1917   // This HeaderFileInfo was externally loaded.
1918   HFI.External = true;
1919   HFI.IsValid = true;
1920   return HFI;
1921 }
1922
1923 void ASTReader::addPendingMacro(IdentifierInfo *II,
1924                                 ModuleFile *M,
1925                                 uint64_t MacroDirectivesOffset) {
1926   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1927   PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1928 }
1929
1930 void ASTReader::ReadDefinedMacros() {
1931   // Note that we are loading defined macros.
1932   Deserializing Macros(this);
1933
1934   for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1935     BitstreamCursor &MacroCursor = I.MacroCursor;
1936
1937     // If there was no preprocessor block, skip this file.
1938     if (MacroCursor.getBitcodeBytes().empty())
1939       continue;
1940
1941     BitstreamCursor Cursor = MacroCursor;
1942     if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
1943       Error(std::move(Err));
1944       return;
1945     }
1946
1947     RecordData Record;
1948     while (true) {
1949       Expected<llvm::BitstreamEntry> MaybeE = Cursor.advanceSkippingSubblocks();
1950       if (!MaybeE) {
1951         Error(MaybeE.takeError());
1952         return;
1953       }
1954       llvm::BitstreamEntry E = MaybeE.get();
1955
1956       switch (E.Kind) {
1957       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1958       case llvm::BitstreamEntry::Error:
1959         Error("malformed block record in AST file");
1960         return;
1961       case llvm::BitstreamEntry::EndBlock:
1962         goto NextCursor;
1963
1964       case llvm::BitstreamEntry::Record: {
1965         Record.clear();
1966         Expected<unsigned> MaybeRecord = Cursor.readRecord(E.ID, Record);
1967         if (!MaybeRecord) {
1968           Error(MaybeRecord.takeError());
1969           return;
1970         }
1971         switch (MaybeRecord.get()) {
1972         default:  // Default behavior: ignore.
1973           break;
1974
1975         case PP_MACRO_OBJECT_LIKE:
1976         case PP_MACRO_FUNCTION_LIKE: {
1977           IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1978           if (II->isOutOfDate())
1979             updateOutOfDateIdentifier(*II);
1980           break;
1981         }
1982
1983         case PP_TOKEN:
1984           // Ignore tokens.
1985           break;
1986         }
1987         break;
1988       }
1989       }
1990     }
1991     NextCursor:  ;
1992   }
1993 }
1994
1995 namespace {
1996
1997   /// Visitor class used to look up identifirs in an AST file.
1998   class IdentifierLookupVisitor {
1999     StringRef Name;
2000     unsigned NameHash;
2001     unsigned PriorGeneration;
2002     unsigned &NumIdentifierLookups;
2003     unsigned &NumIdentifierLookupHits;
2004     IdentifierInfo *Found = nullptr;
2005
2006   public:
2007     IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
2008                             unsigned &NumIdentifierLookups,
2009                             unsigned &NumIdentifierLookupHits)
2010       : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
2011         PriorGeneration(PriorGeneration),
2012         NumIdentifierLookups(NumIdentifierLookups),
2013         NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2014
2015     bool operator()(ModuleFile &M) {
2016       // If we've already searched this module file, skip it now.
2017       if (M.Generation <= PriorGeneration)
2018         return true;
2019
2020       ASTIdentifierLookupTable *IdTable
2021         = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
2022       if (!IdTable)
2023         return false;
2024
2025       ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
2026                                      Found);
2027       ++NumIdentifierLookups;
2028       ASTIdentifierLookupTable::iterator Pos =
2029           IdTable->find_hashed(Name, NameHash, &Trait);
2030       if (Pos == IdTable->end())
2031         return false;
2032
2033       // Dereferencing the iterator has the effect of building the
2034       // IdentifierInfo node and populating it with the various
2035       // declarations it needs.
2036       ++NumIdentifierLookupHits;
2037       Found = *Pos;
2038       return true;
2039     }
2040
2041     // Retrieve the identifier info found within the module
2042     // files.
2043     IdentifierInfo *getIdentifierInfo() const { return Found; }
2044   };
2045
2046 } // namespace
2047
2048 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
2049   // Note that we are loading an identifier.
2050   Deserializing AnIdentifier(this);
2051
2052   unsigned PriorGeneration = 0;
2053   if (getContext().getLangOpts().Modules)
2054     PriorGeneration = IdentifierGeneration[&II];
2055
2056   // If there is a global index, look there first to determine which modules
2057   // provably do not have any results for this identifier.
2058   GlobalModuleIndex::HitSet Hits;
2059   GlobalModuleIndex::HitSet *HitsPtr = nullptr;
2060   if (!loadGlobalIndex()) {
2061     if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
2062       HitsPtr = &Hits;
2063     }
2064   }
2065
2066   IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
2067                                   NumIdentifierLookups,
2068                                   NumIdentifierLookupHits);
2069   ModuleMgr.visit(Visitor, HitsPtr);
2070   markIdentifierUpToDate(&II);
2071 }
2072
2073 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
2074   if (!II)
2075     return;
2076
2077   II->setOutOfDate(false);
2078
2079   // Update the generation for this identifier.
2080   if (getContext().getLangOpts().Modules)
2081     IdentifierGeneration[II] = getGeneration();
2082 }
2083
2084 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
2085                                     const PendingMacroInfo &PMInfo) {
2086   ModuleFile &M = *PMInfo.M;
2087
2088   BitstreamCursor &Cursor = M.MacroCursor;
2089   SavedStreamPosition SavedPosition(Cursor);
2090   if (llvm::Error Err = Cursor.JumpToBit(PMInfo.MacroDirectivesOffset)) {
2091     Error(std::move(Err));
2092     return;
2093   }
2094
2095   struct ModuleMacroRecord {
2096     SubmoduleID SubModID;
2097     MacroInfo *MI;
2098     SmallVector<SubmoduleID, 8> Overrides;
2099   };
2100   llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
2101
2102   // We expect to see a sequence of PP_MODULE_MACRO records listing exported
2103   // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
2104   // macro histroy.
2105   RecordData Record;
2106   while (true) {
2107     Expected<llvm::BitstreamEntry> MaybeEntry =
2108         Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2109     if (!MaybeEntry) {
2110       Error(MaybeEntry.takeError());
2111       return;
2112     }
2113     llvm::BitstreamEntry Entry = MaybeEntry.get();
2114
2115     if (Entry.Kind != llvm::BitstreamEntry::Record) {
2116       Error("malformed block record in AST file");
2117       return;
2118     }
2119
2120     Record.clear();
2121     Expected<unsigned> MaybePP = Cursor.readRecord(Entry.ID, Record);
2122     if (!MaybePP) {
2123       Error(MaybePP.takeError());
2124       return;
2125     }
2126     switch ((PreprocessorRecordTypes)MaybePP.get()) {
2127     case PP_MACRO_DIRECTIVE_HISTORY:
2128       break;
2129
2130     case PP_MODULE_MACRO: {
2131       ModuleMacros.push_back(ModuleMacroRecord());
2132       auto &Info = ModuleMacros.back();
2133       Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2134       Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2135       for (int I = 2, N = Record.size(); I != N; ++I)
2136         Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2137       continue;
2138     }
2139
2140     default:
2141       Error("malformed block record in AST file");
2142       return;
2143     }
2144
2145     // We found the macro directive history; that's the last record
2146     // for this macro.
2147     break;
2148   }
2149
2150   // Module macros are listed in reverse dependency order.
2151   {
2152     std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2153     llvm::SmallVector<ModuleMacro*, 8> Overrides;
2154     for (auto &MMR : ModuleMacros) {
2155       Overrides.clear();
2156       for (unsigned ModID : MMR.Overrides) {
2157         Module *Mod = getSubmodule(ModID);
2158         auto *Macro = PP.getModuleMacro(Mod, II);
2159         assert(Macro && "missing definition for overridden macro");
2160         Overrides.push_back(Macro);
2161       }
2162
2163       bool Inserted = false;
2164       Module *Owner = getSubmodule(MMR.SubModID);
2165       PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2166     }
2167   }
2168
2169   // Don't read the directive history for a module; we don't have anywhere
2170   // to put it.
2171   if (M.isModule())
2172     return;
2173
2174   // Deserialize the macro directives history in reverse source-order.
2175   MacroDirective *Latest = nullptr, *Earliest = nullptr;
2176   unsigned Idx = 0, N = Record.size();
2177   while (Idx < N) {
2178     MacroDirective *MD = nullptr;
2179     SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2180     MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2181     switch (K) {
2182     case MacroDirective::MD_Define: {
2183       MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2184       MD = PP.AllocateDefMacroDirective(MI, Loc);
2185       break;
2186     }
2187     case MacroDirective::MD_Undefine:
2188       MD = PP.AllocateUndefMacroDirective(Loc);
2189       break;
2190     case MacroDirective::MD_Visibility:
2191       bool isPublic = Record[Idx++];
2192       MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2193       break;
2194     }
2195
2196     if (!Latest)
2197       Latest = MD;
2198     if (Earliest)
2199       Earliest->setPrevious(MD);
2200     Earliest = MD;
2201   }
2202
2203   if (Latest)
2204     PP.setLoadedMacroDirective(II, Earliest, Latest);
2205 }
2206
2207 ASTReader::InputFileInfo
2208 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2209   // Go find this input file.
2210   BitstreamCursor &Cursor = F.InputFilesCursor;
2211   SavedStreamPosition SavedPosition(Cursor);
2212   if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2213     // FIXME this drops errors on the floor.
2214     consumeError(std::move(Err));
2215   }
2216
2217   Expected<unsigned> MaybeCode = Cursor.ReadCode();
2218   if (!MaybeCode) {
2219     // FIXME this drops errors on the floor.
2220     consumeError(MaybeCode.takeError());
2221   }
2222   unsigned Code = MaybeCode.get();
2223   RecordData Record;
2224   StringRef Blob;
2225
2226   if (Expected<unsigned> Maybe = Cursor.readRecord(Code, Record, &Blob))
2227     assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE &&
2228            "invalid record type for input file");
2229   else {
2230     // FIXME this drops errors on the floor.
2231     consumeError(Maybe.takeError());
2232   }
2233
2234   assert(Record[0] == ID && "Bogus stored ID or offset");
2235   InputFileInfo R;
2236   R.StoredSize = static_cast<off_t>(Record[1]);
2237   R.StoredTime = static_cast<time_t>(Record[2]);
2238   R.Overridden = static_cast<bool>(Record[3]);
2239   R.Transient = static_cast<bool>(Record[4]);
2240   R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2241   R.Filename = Blob;
2242   ResolveImportedPath(F, R.Filename);
2243   return R;
2244 }
2245
2246 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2247 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2248   // If this ID is bogus, just return an empty input file.
2249   if (ID == 0 || ID > F.InputFilesLoaded.size())
2250     return InputFile();
2251
2252   // If we've already loaded this input file, return it.
2253   if (F.InputFilesLoaded[ID-1].getFile())
2254     return F.InputFilesLoaded[ID-1];
2255
2256   if (F.InputFilesLoaded[ID-1].isNotFound())
2257     return InputFile();
2258
2259   // Go find this input file.
2260   BitstreamCursor &Cursor = F.InputFilesCursor;
2261   SavedStreamPosition SavedPosition(Cursor);
2262   if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2263     // FIXME this drops errors on the floor.
2264     consumeError(std::move(Err));
2265   }
2266
2267   InputFileInfo FI = readInputFileInfo(F, ID);
2268   off_t StoredSize = FI.StoredSize;
2269   time_t StoredTime = FI.StoredTime;
2270   bool Overridden = FI.Overridden;
2271   bool Transient = FI.Transient;
2272   StringRef Filename = FI.Filename;
2273
2274   const FileEntry *File = nullptr;
2275   if (auto FE = FileMgr.getFile(Filename, /*OpenFile=*/false))
2276     File = *FE;
2277
2278   // If we didn't find the file, resolve it relative to the
2279   // original directory from which this AST file was created.
2280   if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2281       F.OriginalDir != F.BaseDirectory) {
2282     std::string Resolved = resolveFileRelativeToOriginalDir(
2283         Filename, F.OriginalDir, F.BaseDirectory);
2284     if (!Resolved.empty())
2285       if (auto FE = FileMgr.getFile(Resolved))
2286         File = *FE;
2287   }
2288
2289   // For an overridden file, create a virtual file with the stored
2290   // size/timestamp.
2291   if ((Overridden || Transient) && File == nullptr)
2292     File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2293
2294   if (File == nullptr) {
2295     if (Complain) {
2296       std::string ErrorStr = "could not find file '";
2297       ErrorStr += Filename;
2298       ErrorStr += "' referenced by AST file '";
2299       ErrorStr += F.FileName;
2300       ErrorStr += "'";
2301       Error(ErrorStr);
2302     }
2303     // Record that we didn't find the file.
2304     F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2305     return InputFile();
2306   }
2307
2308   // Check if there was a request to override the contents of the file
2309   // that was part of the precompiled header. Overriding such a file
2310   // can lead to problems when lexing using the source locations from the
2311   // PCH.
2312   SourceManager &SM = getSourceManager();
2313   // FIXME: Reject if the overrides are different.
2314   if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2315     if (Complain)
2316       Error(diag::err_fe_pch_file_overridden, Filename);
2317     // After emitting the diagnostic, recover by disabling the override so
2318     // that the original file will be used.
2319     //
2320     // FIXME: This recovery is just as broken as the original state; there may
2321     // be another precompiled module that's using the overridden contents, or
2322     // we might be half way through parsing it. Instead, we should treat the
2323     // overridden contents as belonging to a separate FileEntry.
2324     SM.disableFileContentsOverride(File);
2325     // The FileEntry is a virtual file entry with the size of the contents
2326     // that would override the original contents. Set it to the original's
2327     // size/time.
2328     FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2329                             StoredSize, StoredTime);
2330   }
2331
2332   bool IsOutOfDate = false;
2333
2334   // For an overridden file, there is nothing to validate.
2335   if (!Overridden && //
2336       (StoredSize != File->getSize() ||
2337        (StoredTime && StoredTime != File->getModificationTime() &&
2338         !DisableValidation)
2339        )) {
2340     if (Complain) {
2341       // Build a list of the PCH imports that got us here (in reverse).
2342       SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2343       while (!ImportStack.back()->ImportedBy.empty())
2344         ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2345
2346       // The top-level PCH is stale.
2347       StringRef TopLevelPCHName(ImportStack.back()->FileName);
2348       unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2349       if (DiagnosticKind == 0)
2350         Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2351       else if (DiagnosticKind == 1)
2352         Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2353       else
2354         Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2355
2356       // Print the import stack.
2357       if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2358         Diag(diag::note_pch_required_by)
2359           << Filename << ImportStack[0]->FileName;
2360         for (unsigned I = 1; I < ImportStack.size(); ++I)
2361           Diag(diag::note_pch_required_by)
2362             << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2363       }
2364
2365       if (!Diags.isDiagnosticInFlight())
2366         Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2367     }
2368
2369     IsOutOfDate = true;
2370   }
2371   // FIXME: If the file is overridden and we've already opened it,
2372   // issue an error (or split it into a separate FileEntry).
2373
2374   InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2375
2376   // Note that we've loaded this input file.
2377   F.InputFilesLoaded[ID-1] = IF;
2378   return IF;
2379 }
2380
2381 /// If we are loading a relocatable PCH or module file, and the filename
2382 /// is not an absolute path, add the system or module root to the beginning of
2383 /// the file name.
2384 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2385   // Resolve relative to the base directory, if we have one.
2386   if (!M.BaseDirectory.empty())
2387     return ResolveImportedPath(Filename, M.BaseDirectory);
2388 }
2389
2390 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2391   if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2392     return;
2393
2394   SmallString<128> Buffer;
2395   llvm::sys::path::append(Buffer, Prefix, Filename);
2396   Filename.assign(Buffer.begin(), Buffer.end());
2397 }
2398
2399 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2400   switch (ARR) {
2401   case ASTReader::Failure: return true;
2402   case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2403   case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2404   case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2405   case ASTReader::ConfigurationMismatch:
2406     return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2407   case ASTReader::HadErrors: return true;
2408   case ASTReader::Success: return false;
2409   }
2410
2411   llvm_unreachable("unknown ASTReadResult");
2412 }
2413
2414 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2415     BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2416     bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2417     std::string &SuggestedPredefines) {
2418   if (llvm::Error Err = Stream.EnterSubBlock(OPTIONS_BLOCK_ID)) {
2419     // FIXME this drops errors on the floor.
2420     consumeError(std::move(Err));
2421     return Failure;
2422   }
2423
2424   // Read all of the records in the options block.
2425   RecordData Record;
2426   ASTReadResult Result = Success;
2427   while (true) {
2428     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2429     if (!MaybeEntry) {
2430       // FIXME this drops errors on the floor.
2431       consumeError(MaybeEntry.takeError());
2432       return Failure;
2433     }
2434     llvm::BitstreamEntry Entry = MaybeEntry.get();
2435
2436     switch (Entry.Kind) {
2437     case llvm::BitstreamEntry::Error:
2438     case llvm::BitstreamEntry::SubBlock:
2439       return Failure;
2440
2441     case llvm::BitstreamEntry::EndBlock:
2442       return Result;
2443
2444     case llvm::BitstreamEntry::Record:
2445       // The interesting case.
2446       break;
2447     }
2448
2449     // Read and process a record.
2450     Record.clear();
2451     Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
2452     if (!MaybeRecordType) {
2453       // FIXME this drops errors on the floor.
2454       consumeError(MaybeRecordType.takeError());
2455       return Failure;
2456     }
2457     switch ((OptionsRecordTypes)MaybeRecordType.get()) {
2458     case LANGUAGE_OPTIONS: {
2459       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2460       if (ParseLanguageOptions(Record, Complain, Listener,
2461                                AllowCompatibleConfigurationMismatch))
2462         Result = ConfigurationMismatch;
2463       break;
2464     }
2465
2466     case TARGET_OPTIONS: {
2467       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2468       if (ParseTargetOptions(Record, Complain, Listener,
2469                              AllowCompatibleConfigurationMismatch))
2470         Result = ConfigurationMismatch;
2471       break;
2472     }
2473
2474     case FILE_SYSTEM_OPTIONS: {
2475       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2476       if (!AllowCompatibleConfigurationMismatch &&
2477           ParseFileSystemOptions(Record, Complain, Listener))
2478         Result = ConfigurationMismatch;
2479       break;
2480     }
2481
2482     case HEADER_SEARCH_OPTIONS: {
2483       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2484       if (!AllowCompatibleConfigurationMismatch &&
2485           ParseHeaderSearchOptions(Record, Complain, Listener))
2486         Result = ConfigurationMismatch;
2487       break;
2488     }
2489
2490     case PREPROCESSOR_OPTIONS:
2491       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2492       if (!AllowCompatibleConfigurationMismatch &&
2493           ParsePreprocessorOptions(Record, Complain, Listener,
2494                                    SuggestedPredefines))
2495         Result = ConfigurationMismatch;
2496       break;
2497     }
2498   }
2499 }
2500
2501 ASTReader::ASTReadResult
2502 ASTReader::ReadControlBlock(ModuleFile &F,
2503                             SmallVectorImpl<ImportedModule> &Loaded,
2504                             const ModuleFile *ImportedBy,
2505                             unsigned ClientLoadCapabilities) {
2506   BitstreamCursor &Stream = F.Stream;
2507   ASTReadResult Result = Success;
2508
2509   if (llvm::Error Err = Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2510     Error(std::move(Err));
2511     return Failure;
2512   }
2513
2514   // Lambda to read the unhashed control block the first time it's called.
2515   //
2516   // For PCM files, the unhashed control block cannot be read until after the
2517   // MODULE_NAME record.  However, PCH files have no MODULE_NAME, and yet still
2518   // need to look ahead before reading the IMPORTS record.  For consistency,
2519   // this block is always read somehow (see BitstreamEntry::EndBlock).
2520   bool HasReadUnhashedControlBlock = false;
2521   auto readUnhashedControlBlockOnce = [&]() {
2522     if (!HasReadUnhashedControlBlock) {
2523       HasReadUnhashedControlBlock = true;
2524       if (ASTReadResult Result =
2525               readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2526         return Result;
2527     }
2528     return Success;
2529   };
2530
2531   // Read all of the records and blocks in the control block.
2532   RecordData Record;
2533   unsigned NumInputs = 0;
2534   unsigned NumUserInputs = 0;
2535   StringRef BaseDirectoryAsWritten;
2536   while (true) {
2537     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2538     if (!MaybeEntry) {
2539       Error(MaybeEntry.takeError());
2540       return Failure;
2541     }
2542     llvm::BitstreamEntry Entry = MaybeEntry.get();
2543
2544     switch (Entry.Kind) {
2545     case llvm::BitstreamEntry::Error:
2546       Error("malformed block record in AST file");
2547       return Failure;
2548     case llvm::BitstreamEntry::EndBlock: {
2549       // Validate the module before returning.  This call catches an AST with
2550       // no module name and no imports.
2551       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2552         return Result;
2553
2554       // Validate input files.
2555       const HeaderSearchOptions &HSOpts =
2556           PP.getHeaderSearchInfo().getHeaderSearchOpts();
2557
2558       // All user input files reside at the index range [0, NumUserInputs), and
2559       // system input files reside at [NumUserInputs, NumInputs). For explicitly
2560       // loaded module files, ignore missing inputs.
2561       if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2562           F.Kind != MK_PrebuiltModule) {
2563         bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2564
2565         // If we are reading a module, we will create a verification timestamp,
2566         // so we verify all input files.  Otherwise, verify only user input
2567         // files.
2568
2569         unsigned N = NumUserInputs;
2570         if (ValidateSystemInputs ||
2571             (HSOpts.ModulesValidateOncePerBuildSession &&
2572              F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2573              F.Kind == MK_ImplicitModule))
2574           N = NumInputs;
2575
2576         for (unsigned I = 0; I < N; ++I) {
2577           InputFile IF = getInputFile(F, I+1, Complain);
2578           if (!IF.getFile() || IF.isOutOfDate())
2579             return OutOfDate;
2580         }
2581       }
2582
2583       if (Listener)
2584         Listener->visitModuleFile(F.FileName, F.Kind);
2585
2586       if (Listener && Listener->needsInputFileVisitation()) {
2587         unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2588                                                                 : NumUserInputs;
2589         for (unsigned I = 0; I < N; ++I) {
2590           bool IsSystem = I >= NumUserInputs;
2591           InputFileInfo FI = readInputFileInfo(F, I+1);
2592           Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2593                                    F.Kind == MK_ExplicitModule ||
2594                                    F.Kind == MK_PrebuiltModule);
2595         }
2596       }
2597
2598       return Result;
2599     }
2600
2601     case llvm::BitstreamEntry::SubBlock:
2602       switch (Entry.ID) {
2603       case INPUT_FILES_BLOCK_ID:
2604         F.InputFilesCursor = Stream;
2605         if (llvm::Error Err = Stream.SkipBlock()) {
2606           Error(std::move(Err));
2607           return Failure;
2608         }
2609         if (ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2610           Error("malformed block record in AST file");
2611           return Failure;
2612         }
2613         continue;
2614
2615       case OPTIONS_BLOCK_ID:
2616         // If we're reading the first module for this group, check its options
2617         // are compatible with ours. For modules it imports, no further checking
2618         // is required, because we checked them when we built it.
2619         if (Listener && !ImportedBy) {
2620           // Should we allow the configuration of the module file to differ from
2621           // the configuration of the current translation unit in a compatible
2622           // way?
2623           //
2624           // FIXME: Allow this for files explicitly specified with -include-pch.
2625           bool AllowCompatibleConfigurationMismatch =
2626               F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2627
2628           Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2629                                     AllowCompatibleConfigurationMismatch,
2630                                     *Listener, SuggestedPredefines);
2631           if (Result == Failure) {
2632             Error("malformed block record in AST file");
2633             return Result;
2634           }
2635
2636           if (DisableValidation ||
2637               (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2638             Result = Success;
2639
2640           // If we can't load the module, exit early since we likely
2641           // will rebuild the module anyway. The stream may be in the
2642           // middle of a block.
2643           if (Result != Success)
2644             return Result;
2645         } else if (llvm::Error Err = Stream.SkipBlock()) {
2646           Error(std::move(Err));
2647           return Failure;
2648         }
2649         continue;
2650
2651       default:
2652         if (llvm::Error Err = Stream.SkipBlock()) {
2653           Error(std::move(Err));
2654           return Failure;
2655         }
2656         continue;
2657       }
2658
2659     case llvm::BitstreamEntry::Record:
2660       // The interesting case.
2661       break;
2662     }
2663
2664     // Read and process a record.
2665     Record.clear();
2666     StringRef Blob;
2667     Expected<unsigned> MaybeRecordType =
2668         Stream.readRecord(Entry.ID, Record, &Blob);
2669     if (!MaybeRecordType) {
2670       Error(MaybeRecordType.takeError());
2671       return Failure;
2672     }
2673     switch ((ControlRecordTypes)MaybeRecordType.get()) {
2674     case METADATA: {
2675       if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2676         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2677           Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2678                                         : diag::err_pch_version_too_new);
2679         return VersionMismatch;
2680       }
2681
2682       bool hasErrors = Record[7];
2683       if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2684         Diag(diag::err_pch_with_compiler_errors);
2685         return HadErrors;
2686       }
2687       if (hasErrors) {
2688         Diags.ErrorOccurred = true;
2689         Diags.UncompilableErrorOccurred = true;
2690         Diags.UnrecoverableErrorOccurred = true;
2691       }
2692
2693       F.RelocatablePCH = Record[4];
2694       // Relative paths in a relocatable PCH are relative to our sysroot.
2695       if (F.RelocatablePCH)
2696         F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2697
2698       F.HasTimestamps = Record[5];
2699
2700       F.PCHHasObjectFile = Record[6];
2701
2702       const std::string &CurBranch = getClangFullRepositoryVersion();
2703       StringRef ASTBranch = Blob;
2704       if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2705         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2706           Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2707         return VersionMismatch;
2708       }
2709       break;
2710     }
2711
2712     case IMPORTS: {
2713       // Validate the AST before processing any imports (otherwise, untangling
2714       // them can be error-prone and expensive).  A module will have a name and
2715       // will already have been validated, but this catches the PCH case.
2716       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2717         return Result;
2718
2719       // Load each of the imported PCH files.
2720       unsigned Idx = 0, N = Record.size();
2721       while (Idx < N) {
2722         // Read information about the AST file.
2723         ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2724         // The import location will be the local one for now; we will adjust
2725         // all import locations of module imports after the global source
2726         // location info are setup, in ReadAST.
2727         SourceLocation ImportLoc =
2728             ReadUntranslatedSourceLocation(Record[Idx++]);
2729         off_t StoredSize = (off_t)Record[Idx++];
2730         time_t StoredModTime = (time_t)Record[Idx++];
2731         ASTFileSignature StoredSignature = {
2732             {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2733               (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2734               (uint32_t)Record[Idx++]}}};
2735
2736         std::string ImportedName = ReadString(Record, Idx);
2737         std::string ImportedFile;
2738
2739         // For prebuilt and explicit modules first consult the file map for
2740         // an override. Note that here we don't search prebuilt module
2741         // directories, only the explicit name to file mappings. Also, we will
2742         // still verify the size/signature making sure it is essentially the
2743         // same file but perhaps in a different location.
2744         if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2745           ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2746             ImportedName, /*FileMapOnly*/ true);
2747
2748         if (ImportedFile.empty())
2749           // Use BaseDirectoryAsWritten to ensure we use the same path in the
2750           // ModuleCache as when writing.
2751           ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2752         else
2753           SkipPath(Record, Idx);
2754
2755         // If our client can't cope with us being out of date, we can't cope with
2756         // our dependency being missing.
2757         unsigned Capabilities = ClientLoadCapabilities;
2758         if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2759           Capabilities &= ~ARR_Missing;
2760
2761         // Load the AST file.
2762         auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2763                                   Loaded, StoredSize, StoredModTime,
2764                                   StoredSignature, Capabilities);
2765
2766         // If we diagnosed a problem, produce a backtrace.
2767         if (isDiagnosedResult(Result, Capabilities))
2768           Diag(diag::note_module_file_imported_by)
2769               << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2770
2771         switch (Result) {
2772         case Failure: return Failure;
2773           // If we have to ignore the dependency, we'll have to ignore this too.
2774         case Missing:
2775         case OutOfDate: return OutOfDate;
2776         case VersionMismatch: return VersionMismatch;
2777         case ConfigurationMismatch: return ConfigurationMismatch;
2778         case HadErrors: return HadErrors;
2779         case Success: break;
2780         }
2781       }
2782       break;
2783     }
2784
2785     case ORIGINAL_FILE:
2786       F.OriginalSourceFileID = FileID::get(Record[0]);
2787       F.ActualOriginalSourceFileName = Blob;
2788       F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2789       ResolveImportedPath(F, F.OriginalSourceFileName);
2790       break;
2791
2792     case ORIGINAL_FILE_ID:
2793       F.OriginalSourceFileID = FileID::get(Record[0]);
2794       break;
2795
2796     case ORIGINAL_PCH_DIR:
2797       F.OriginalDir = Blob;
2798       break;
2799
2800     case MODULE_NAME:
2801       F.ModuleName = Blob;
2802       Diag(diag::remark_module_import)
2803           << F.ModuleName << F.FileName << (ImportedBy ? true : false)
2804           << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
2805       if (Listener)
2806         Listener->ReadModuleName(F.ModuleName);
2807
2808       // Validate the AST as soon as we have a name so we can exit early on
2809       // failure.
2810       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2811         return Result;
2812
2813       break;
2814
2815     case MODULE_DIRECTORY: {
2816       // Save the BaseDirectory as written in the PCM for computing the module
2817       // filename for the ModuleCache.
2818       BaseDirectoryAsWritten = Blob;
2819       assert(!F.ModuleName.empty() &&
2820              "MODULE_DIRECTORY found before MODULE_NAME");
2821       // If we've already loaded a module map file covering this module, we may
2822       // have a better path for it (relative to the current build).
2823       Module *M = PP.getHeaderSearchInfo().lookupModule(
2824           F.ModuleName, /*AllowSearch*/ true,
2825           /*AllowExtraModuleMapSearch*/ true);
2826       if (M && M->Directory) {
2827         // If we're implicitly loading a module, the base directory can't
2828         // change between the build and use.
2829         // Don't emit module relocation error if we have -fno-validate-pch
2830         if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2831             F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2832           auto BuildDir = PP.getFileManager().getDirectory(Blob);
2833           if (!BuildDir || *BuildDir != M->Directory) {
2834             if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2835               Diag(diag::err_imported_module_relocated)
2836                   << F.ModuleName << Blob << M->Directory->getName();
2837             return OutOfDate;
2838           }
2839         }
2840         F.BaseDirectory = M->Directory->getName();
2841       } else {
2842         F.BaseDirectory = Blob;
2843       }
2844       break;
2845     }
2846
2847     case MODULE_MAP_FILE:
2848       if (ASTReadResult Result =
2849               ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2850         return Result;
2851       break;
2852
2853     case INPUT_FILE_OFFSETS:
2854       NumInputs = Record[0];
2855       NumUserInputs = Record[1];
2856       F.InputFileOffsets =
2857           (const llvm::support::unaligned_uint64_t *)Blob.data();
2858       F.InputFilesLoaded.resize(NumInputs);
2859       F.NumUserInputFiles = NumUserInputs;
2860       break;
2861     }
2862   }
2863 }
2864
2865 ASTReader::ASTReadResult
2866 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2867   BitstreamCursor &Stream = F.Stream;
2868
2869   if (llvm::Error Err = Stream.EnterSubBlock(AST_BLOCK_ID)) {
2870     Error(std::move(Err));
2871     return Failure;
2872   }
2873
2874   // Read all of the records and blocks for the AST file.
2875   RecordData Record;
2876   while (true) {
2877     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2878     if (!MaybeEntry) {
2879       Error(MaybeEntry.takeError());
2880       return Failure;
2881     }
2882     llvm::BitstreamEntry Entry = MaybeEntry.get();
2883
2884     switch (Entry.Kind) {
2885     case llvm::BitstreamEntry::Error:
2886       Error("error at end of module block in AST file");
2887       return Failure;
2888     case llvm::BitstreamEntry::EndBlock:
2889       // Outside of C++, we do not store a lookup map for the translation unit.
2890       // Instead, mark it as needing a lookup map to be built if this module
2891       // contains any declarations lexically within it (which it always does!).
2892       // This usually has no cost, since we very rarely need the lookup map for
2893       // the translation unit outside C++.
2894       if (ASTContext *Ctx = ContextObj) {
2895         DeclContext *DC = Ctx->getTranslationUnitDecl();
2896         if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2897           DC->setMustBuildLookupTable();
2898       }
2899
2900       return Success;
2901     case llvm::BitstreamEntry::SubBlock:
2902       switch (Entry.ID) {
2903       case DECLTYPES_BLOCK_ID:
2904         // We lazily load the decls block, but we want to set up the
2905         // DeclsCursor cursor to point into it.  Clone our current bitcode
2906         // cursor to it, enter the block and read the abbrevs in that block.
2907         // With the main cursor, we just skip over it.
2908         F.DeclsCursor = Stream;
2909         if (llvm::Error Err = Stream.SkipBlock()) {
2910           Error(std::move(Err));
2911           return Failure;
2912         }
2913         if (ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2914           Error("malformed block record in AST file");
2915           return Failure;
2916         }
2917         break;
2918
2919       case PREPROCESSOR_BLOCK_ID:
2920         F.MacroCursor = Stream;
2921         if (!PP.getExternalSource())
2922           PP.setExternalSource(this);
2923
2924         if (llvm::Error Err = Stream.SkipBlock()) {
2925           Error(std::move(Err));
2926           return Failure;
2927         }
2928         if (ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2929           Error("malformed block record in AST file");
2930           return Failure;
2931         }
2932         F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2933         break;
2934
2935       case PREPROCESSOR_DETAIL_BLOCK_ID:
2936         F.PreprocessorDetailCursor = Stream;
2937
2938         if (llvm::Error Err = Stream.SkipBlock()) {
2939           Error(std::move(Err));
2940           return Failure;
2941         }
2942         if (ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2943                              PREPROCESSOR_DETAIL_BLOCK_ID)) {
2944           Error("malformed preprocessor detail record in AST file");
2945           return Failure;
2946         }
2947         F.PreprocessorDetailStartOffset
2948         = F.PreprocessorDetailCursor.GetCurrentBitNo();
2949
2950         if (!PP.getPreprocessingRecord())
2951           PP.createPreprocessingRecord();
2952         if (!PP.getPreprocessingRecord()->getExternalSource())
2953           PP.getPreprocessingRecord()->SetExternalSource(*this);
2954         break;
2955
2956       case SOURCE_MANAGER_BLOCK_ID:
2957         if (ReadSourceManagerBlock(F))
2958           return Failure;
2959         break;
2960
2961       case SUBMODULE_BLOCK_ID:
2962         if (ASTReadResult Result =
2963                 ReadSubmoduleBlock(F, ClientLoadCapabilities))
2964           return Result;
2965         break;
2966
2967       case COMMENTS_BLOCK_ID: {
2968         BitstreamCursor C = Stream;
2969
2970         if (llvm::Error Err = Stream.SkipBlock()) {
2971           Error(std::move(Err));
2972           return Failure;
2973         }
2974         if (ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2975           Error("malformed comments block in AST file");
2976           return Failure;
2977         }
2978         CommentsCursors.push_back(std::make_pair(C, &F));
2979         break;
2980       }
2981
2982       default:
2983         if (llvm::Error Err = Stream.SkipBlock()) {
2984           Error(std::move(Err));
2985           return Failure;
2986         }
2987         break;
2988       }
2989       continue;
2990
2991     case llvm::BitstreamEntry::Record:
2992       // The interesting case.
2993       break;
2994     }
2995
2996     // Read and process a record.
2997     Record.clear();
2998     StringRef Blob;
2999     Expected<unsigned> MaybeRecordType =
3000         Stream.readRecord(Entry.ID, Record, &Blob);
3001     if (!MaybeRecordType) {
3002       Error(MaybeRecordType.takeError());
3003       return Failure;
3004     }
3005     ASTRecordTypes RecordType = (ASTRecordTypes)MaybeRecordType.get();
3006
3007     // If we're not loading an AST context, we don't care about most records.
3008     if (!ContextObj) {
3009       switch (RecordType) {
3010       case IDENTIFIER_TABLE:
3011       case IDENTIFIER_OFFSET:
3012       case INTERESTING_IDENTIFIERS:
3013       case STATISTICS:
3014       case PP_CONDITIONAL_STACK:
3015       case PP_COUNTER_VALUE:
3016       case SOURCE_LOCATION_OFFSETS:
3017       case MODULE_OFFSET_MAP:
3018       case SOURCE_MANAGER_LINE_TABLE:
3019       case SOURCE_LOCATION_PRELOADS:
3020       case PPD_ENTITIES_OFFSETS:
3021       case HEADER_SEARCH_TABLE:
3022       case IMPORTED_MODULES:
3023       case MACRO_OFFSET:
3024         break;
3025       default:
3026         continue;
3027       }
3028     }
3029
3030     switch (RecordType) {
3031     default:  // Default behavior: ignore.
3032       break;
3033
3034     case TYPE_OFFSET: {
3035       if (F.LocalNumTypes != 0) {
3036         Error("duplicate TYPE_OFFSET record in AST file");
3037         return Failure;
3038       }
3039       F.TypeOffsets = (const uint32_t *)Blob.data();
3040       F.LocalNumTypes = Record[0];
3041       unsigned LocalBaseTypeIndex = Record[1];
3042       F.BaseTypeIndex = getTotalNumTypes();
3043
3044       if (F.LocalNumTypes > 0) {
3045         // Introduce the global -> local mapping for types within this module.
3046         GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3047
3048         // Introduce the local -> global mapping for types within this module.
3049         F.TypeRemap.insertOrReplace(
3050           std::make_pair(LocalBaseTypeIndex,
3051                          F.BaseTypeIndex - LocalBaseTypeIndex));
3052
3053         TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
3054       }
3055       break;
3056     }
3057
3058     case DECL_OFFSET: {
3059       if (F.LocalNumDecls != 0) {
3060         Error("duplicate DECL_OFFSET record in AST file");
3061         return Failure;
3062       }
3063       F.DeclOffsets = (const DeclOffset *)Blob.data();
3064       F.LocalNumDecls = Record[0];
3065       unsigned LocalBaseDeclID = Record[1];
3066       F.BaseDeclID = getTotalNumDecls();
3067
3068       if (F.LocalNumDecls > 0) {
3069         // Introduce the global -> local mapping for declarations within this
3070         // module.
3071         GlobalDeclMap.insert(
3072           std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
3073
3074         // Introduce the local -> global mapping for declarations within this
3075         // module.
3076         F.DeclRemap.insertOrReplace(
3077           std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
3078
3079         // Introduce the global -> local mapping for declarations within this
3080         // module.
3081         F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
3082
3083         DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
3084       }
3085       break;
3086     }
3087
3088     case TU_UPDATE_LEXICAL: {
3089       DeclContext *TU = ContextObj->getTranslationUnitDecl();
3090       LexicalContents Contents(
3091           reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
3092               Blob.data()),
3093           static_cast<unsigned int>(Blob.size() / 4));
3094       TULexicalDecls.push_back(std::make_pair(&F, Contents));
3095       TU->setHasExternalLexicalStorage(true);
3096       break;
3097     }
3098
3099     case UPDATE_VISIBLE: {
3100       unsigned Idx = 0;
3101       serialization::DeclID ID = ReadDeclID(F, Record, Idx);
3102       auto *Data = (const unsigned char*)Blob.data();
3103       PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
3104       // If we've already loaded the decl, perform the updates when we finish
3105       // loading this block.
3106       if (Decl *D = GetExistingDecl(ID))
3107         PendingUpdateRecords.push_back(
3108             PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3109       break;
3110     }
3111
3112     case IDENTIFIER_TABLE:
3113       F.IdentifierTableData = Blob.data();
3114       if (Record[0]) {
3115         F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
3116             (const unsigned char *)F.IdentifierTableData + Record[0],
3117             (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
3118             (const unsigned char *)F.IdentifierTableData,
3119             ASTIdentifierLookupTrait(*this, F));
3120
3121         PP.getIdentifierTable().setExternalIdentifierLookup(this);
3122       }
3123       break;
3124
3125     case IDENTIFIER_OFFSET: {
3126       if (F.LocalNumIdentifiers != 0) {
3127         Error("duplicate IDENTIFIER_OFFSET record in AST file");
3128         return Failure;
3129       }
3130       F.IdentifierOffsets = (const uint32_t *)Blob.data();
3131       F.LocalNumIdentifiers = Record[0];
3132       unsigned LocalBaseIdentifierID = Record[1];
3133       F.BaseIdentifierID = getTotalNumIdentifiers();
3134
3135       if (F.LocalNumIdentifiers > 0) {
3136         // Introduce the global -> local mapping for identifiers within this
3137         // module.
3138         GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3139                                                   &F));
3140
3141         // Introduce the local -> global mapping for identifiers within this
3142         // module.
3143         F.IdentifierRemap.insertOrReplace(
3144           std::make_pair(LocalBaseIdentifierID,
3145                          F.BaseIdentifierID - LocalBaseIdentifierID));
3146
3147         IdentifiersLoaded.resize(IdentifiersLoaded.size()
3148                                  + F.LocalNumIdentifiers);
3149       }
3150       break;
3151     }
3152
3153     case INTERESTING_IDENTIFIERS:
3154       F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
3155       break;
3156
3157     case EAGERLY_DESERIALIZED_DECLS:
3158       // FIXME: Skip reading this record if our ASTConsumer doesn't care
3159       // about "interesting" decls (for instance, if we're building a module).
3160       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3161         EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3162       break;
3163
3164     case MODULAR_CODEGEN_DECLS:
3165       // FIXME: Skip reading this record if our ASTConsumer doesn't care about
3166       // them (ie: if we're not codegenerating this module).
3167       if (F.Kind == MK_MainFile)
3168         for (unsigned I = 0, N = Record.size(); I != N; ++I)
3169           EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3170       break;
3171
3172     case SPECIAL_TYPES:
3173       if (SpecialTypes.empty()) {
3174         for (unsigned I = 0, N = Record.size(); I != N; ++I)
3175           SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3176         break;
3177       }
3178
3179       if (SpecialTypes.size() != Record.size()) {
3180         Error("invalid special-types record");
3181         return Failure;
3182       }
3183
3184       for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3185         serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
3186         if (!SpecialTypes[I])
3187           SpecialTypes[I] = ID;
3188         // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
3189         // merge step?
3190       }
3191       break;
3192
3193     case STATISTICS:
3194       TotalNumStatements += Record[0];
3195       TotalNumMacros += Record[1];
3196       TotalLexicalDeclContexts += Record[2];
3197       TotalVisibleDeclContexts += Record[3];
3198       break;
3199
3200     case UNUSED_FILESCOPED_DECLS:
3201       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3202         UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3203       break;
3204
3205     case DELEGATING_CTORS:
3206       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3207         DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3208       break;
3209
3210     case WEAK_UNDECLARED_IDENTIFIERS:
3211       if (Record.size() % 4 != 0) {
3212         Error("invalid weak identifiers record");
3213         return Failure;
3214       }
3215
3216       // FIXME: Ignore weak undeclared identifiers from non-original PCH
3217       // files. This isn't the way to do it :)
3218       WeakUndeclaredIdentifiers.clear();
3219
3220       // Translate the weak, undeclared identifiers into global IDs.
3221       for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3222         WeakUndeclaredIdentifiers.push_back(
3223           getGlobalIdentifierID(F, Record[I++]));
3224         WeakUndeclaredIdentifiers.push_back(
3225           getGlobalIdentifierID(F, Record[I++]));
3226         WeakUndeclaredIdentifiers.push_back(
3227           ReadSourceLocation(F, Record, I).getRawEncoding());
3228         WeakUndeclaredIdentifiers.push_back(Record[I++]);
3229       }
3230       break;
3231
3232     case SELECTOR_OFFSETS: {
3233       F.SelectorOffsets = (const uint32_t *)Blob.data();
3234       F.LocalNumSelectors = Record[0];
3235       unsigned LocalBaseSelectorID = Record[1];
3236       F.BaseSelectorID = getTotalNumSelectors();
3237
3238       if (F.LocalNumSelectors > 0) {
3239         // Introduce the global -> local mapping for selectors within this
3240         // module.
3241         GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3242
3243         // Introduce the local -> global mapping for selectors within this
3244         // module.
3245         F.SelectorRemap.insertOrReplace(
3246           std::make_pair(LocalBaseSelectorID,
3247                          F.BaseSelectorID - LocalBaseSelectorID));
3248
3249         SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3250       }
3251       break;
3252     }
3253
3254     case METHOD_POOL:
3255       F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3256       if (Record[0])
3257         F.SelectorLookupTable
3258           = ASTSelectorLookupTable::Create(
3259                         F.SelectorLookupTableData + Record[0],
3260                         F.SelectorLookupTableData,
3261                         ASTSelectorLookupTrait(*this, F));
3262       TotalNumMethodPoolEntries += Record[1];
3263       break;
3264
3265     case REFERENCED_SELECTOR_POOL:
3266       if (!Record.empty()) {
3267         for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3268           ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3269                                                                 Record[Idx++]));
3270           ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3271                                               getRawEncoding());
3272         }
3273       }
3274       break;
3275
3276     case PP_CONDITIONAL_STACK:
3277       if (!Record.empty()) {
3278         unsigned Idx = 0, End = Record.size() - 1;
3279         bool ReachedEOFWhileSkipping = Record[Idx++];
3280         llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3281         if (ReachedEOFWhileSkipping) {
3282           SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3283           SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3284           bool FoundNonSkipPortion = Record[Idx++];
3285           bool FoundElse = Record[Idx++];
3286           SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3287           SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3288                            FoundElse, ElseLoc);
3289         }
3290         SmallVector<PPConditionalInfo, 4> ConditionalStack;
3291         while (Idx < End) {
3292           auto Loc = ReadSourceLocation(F, Record, Idx);
3293           bool WasSkipping = Record[Idx++];
3294           bool FoundNonSkip = Record[Idx++];
3295           bool FoundElse = Record[Idx++];
3296           ConditionalStack.push_back(
3297               {Loc, WasSkipping, FoundNonSkip, FoundElse});
3298         }
3299         PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3300       }
3301       break;
3302
3303     case PP_COUNTER_VALUE:
3304       if (!Record.empty() && Listener)
3305         Listener->ReadCounter(F, Record[0]);
3306       break;
3307
3308     case FILE_SORTED_DECLS:
3309       F.FileSortedDecls = (const DeclID *)Blob.data();
3310       F.NumFileSortedDecls = Record[0];
3311       break;
3312
3313     case SOURCE_LOCATION_OFFSETS: {
3314       F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3315       F.LocalNumSLocEntries = Record[0];
3316       unsigned SLocSpaceSize = Record[1];
3317       std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3318           SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3319                                               SLocSpaceSize);
3320       if (!F.SLocEntryBaseID) {
3321         Error("ran out of source locations");
3322         break;
3323       }
3324       // Make our entry in the range map. BaseID is negative and growing, so
3325       // we invert it. Because we invert it, though, we need the other end of
3326       // the range.
3327       unsigned RangeStart =
3328           unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3329       GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3330       F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3331
3332       // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3333       assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3334       GlobalSLocOffsetMap.insert(
3335           std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3336                            - SLocSpaceSize,&F));
3337
3338       // Initialize the remapping table.
3339       // Invalid stays invalid.
3340       F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3341       // This module. Base was 2 when being compiled.
3342       F.SLocRemap.insertOrReplace(std::make_pair(2U,
3343                                   static_cast<int>(F.SLocEntryBaseOffset - 2)));
3344
3345       TotalNumSLocEntries += F.LocalNumSLocEntries;
3346       break;
3347     }
3348
3349     case MODULE_OFFSET_MAP:
3350       F.ModuleOffsetMap = Blob;
3351       break;
3352
3353     case SOURCE_MANAGER_LINE_TABLE:
3354       if (ParseLineTable(F, Record))
3355         return Failure;
3356       break;
3357
3358     case SOURCE_LOCATION_PRELOADS: {
3359       // Need to transform from the local view (1-based IDs) to the global view,
3360       // which is based off F.SLocEntryBaseID.
3361       if (!F.PreloadSLocEntries.empty()) {
3362         Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3363         return Failure;
3364       }
3365
3366       F.PreloadSLocEntries.swap(Record);
3367       break;
3368     }
3369
3370     case EXT_VECTOR_DECLS:
3371       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3372         ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3373       break;
3374
3375     case VTABLE_USES:
3376       if (Record.size() % 3 != 0) {
3377         Error("Invalid VTABLE_USES record");
3378         return Failure;
3379       }
3380
3381       // Later tables overwrite earlier ones.
3382       // FIXME: Modules will have some trouble with this. This is clearly not
3383       // the right way to do this.
3384       VTableUses.clear();
3385
3386       for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3387         VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3388         VTableUses.push_back(
3389           ReadSourceLocation(F, Record, Idx).getRawEncoding());
3390         VTableUses.push_back(Record[Idx++]);
3391       }
3392       break;
3393
3394     case PENDING_IMPLICIT_INSTANTIATIONS:
3395       if (PendingInstantiations.size() % 2 != 0) {
3396         Error("Invalid existing PendingInstantiations");
3397         return Failure;
3398       }
3399
3400       if (Record.size() % 2 != 0) {
3401         Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3402         return Failure;
3403       }
3404
3405       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3406         PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3407         PendingInstantiations.push_back(
3408           ReadSourceLocation(F, Record, I).getRawEncoding());
3409       }
3410       break;
3411
3412     case SEMA_DECL_REFS:
3413       if (Record.size() != 3) {
3414         Error("Invalid SEMA_DECL_REFS block");
3415         return Failure;
3416       }
3417       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3418         SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3419       break;
3420
3421     case PPD_ENTITIES_OFFSETS: {
3422       F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3423       assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3424       F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3425
3426       unsigned LocalBasePreprocessedEntityID = Record[0];
3427
3428       unsigned StartingID;
3429       if (!PP.getPreprocessingRecord())
3430         PP.createPreprocessingRecord();
3431       if (!PP.getPreprocessingRecord()->getExternalSource())
3432         PP.getPreprocessingRecord()->SetExternalSource(*this);
3433       StartingID
3434         = PP.getPreprocessingRecord()
3435             ->allocateLoadedEntities(F.NumPreprocessedEntities);
3436       F.BasePreprocessedEntityID = StartingID;
3437
3438       if (F.NumPreprocessedEntities > 0) {
3439         // Introduce the global -> local mapping for preprocessed entities in
3440         // this module.
3441         GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3442
3443         // Introduce the local -> global mapping for preprocessed entities in
3444         // this module.
3445         F.PreprocessedEntityRemap.insertOrReplace(
3446           std::make_pair(LocalBasePreprocessedEntityID,
3447             F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3448       }
3449
3450       break;
3451     }
3452
3453     case PPD_SKIPPED_RANGES: {
3454       F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3455       assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3456       F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3457
3458       if (!PP.getPreprocessingRecord())
3459         PP.createPreprocessingRecord();
3460       if (!PP.getPreprocessingRecord()->getExternalSource())
3461         PP.getPreprocessingRecord()->SetExternalSource(*this);
3462       F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3463           ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3464
3465       if (F.NumPreprocessedSkippedRanges > 0)
3466         GlobalSkippedRangeMap.insert(
3467             std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3468       break;
3469     }
3470
3471     case DECL_UPDATE_OFFSETS:
3472       if (Record.size() % 2 != 0) {
3473         Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3474         return Failure;
3475       }
3476       for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3477         GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3478         DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3479
3480         // If we've already loaded the decl, perform the updates when we finish
3481         // loading this block.
3482         if (Decl *D = GetExistingDecl(ID))
3483           PendingUpdateRecords.push_back(
3484               PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3485       }
3486       break;
3487
3488     case OBJC_CATEGORIES_MAP:
3489       if (F.LocalNumObjCCategoriesInMap != 0) {
3490         Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3491         return Failure;
3492       }
3493
3494       F.LocalNumObjCCategoriesInMap = Record[0];
3495       F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3496       break;
3497
3498     case OBJC_CATEGORIES:
3499       F.ObjCCategories.swap(Record);
3500       break;
3501
3502     case CUDA_SPECIAL_DECL_REFS:
3503       // Later tables overwrite earlier ones.
3504       // FIXME: Modules will have trouble with this.
3505       CUDASpecialDeclRefs.clear();
3506       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3507         CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3508       break;
3509
3510     case HEADER_SEARCH_TABLE:
3511       F.HeaderFileInfoTableData = Blob.data();
3512       F.LocalNumHeaderFileInfos = Record[1];
3513       if (Record[0]) {
3514         F.HeaderFileInfoTable
3515           = HeaderFileInfoLookupTable::Create(
3516                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3517                    (const unsigned char *)F.HeaderFileInfoTableData,
3518                    HeaderFileInfoTrait(*this, F,
3519                                        &PP.getHeaderSearchInfo(),
3520                                        Blob.data() + Record[2]));
3521
3522  &nb