7f2c7f09e8a3e37dde2b5fad449152fbd6dd8032
[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       return FileMgr.getFile(Key.Filename);
1827
1828     std::string Resolved = Key.Filename;
1829     Reader.ResolveImportedPath(M, Resolved);
1830     return FileMgr.getFile(Resolved);
1831   };
1832
1833   const FileEntry *FEA = GetFile(a);
1834   const FileEntry *FEB = GetFile(b);
1835   return FEA && FEA == FEB;
1836 }
1837
1838 std::pair<unsigned, unsigned>
1839 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1840   using namespace llvm::support;
1841
1842   unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1843   unsigned DataLen = (unsigned) *d++;
1844   return std::make_pair(KeyLen, DataLen);
1845 }
1846
1847 HeaderFileInfoTrait::internal_key_type
1848 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1849   using namespace llvm::support;
1850
1851   internal_key_type ikey;
1852   ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1853   ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1854   ikey.Filename = (const char *)d;
1855   ikey.Imported = true;
1856   return ikey;
1857 }
1858
1859 HeaderFileInfoTrait::data_type
1860 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1861                               unsigned DataLen) {
1862   using namespace llvm::support;
1863
1864   const unsigned char *End = d + DataLen;
1865   HeaderFileInfo HFI;
1866   unsigned Flags = *d++;
1867   // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1868   HFI.isImport |= (Flags >> 5) & 0x01;
1869   HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1870   HFI.DirInfo = (Flags >> 1) & 0x07;
1871   HFI.IndexHeaderMapHeader = Flags & 0x01;
1872   // FIXME: Find a better way to handle this. Maybe just store a
1873   // "has been included" flag?
1874   HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1875                              HFI.NumIncludes);
1876   HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1877       M, endian::readNext<uint32_t, little, unaligned>(d));
1878   if (unsigned FrameworkOffset =
1879           endian::readNext<uint32_t, little, unaligned>(d)) {
1880     // The framework offset is 1 greater than the actual offset,
1881     // since 0 is used as an indicator for "no framework name".
1882     StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1883     HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1884   }
1885
1886   assert((End - d) % 4 == 0 &&
1887          "Wrong data length in HeaderFileInfo deserialization");
1888   while (d != End) {
1889     uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1890     auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1891     LocalSMID >>= 2;
1892
1893     // This header is part of a module. Associate it with the module to enable
1894     // implicit module import.
1895     SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1896     Module *Mod = Reader.getSubmodule(GlobalSMID);
1897     FileManager &FileMgr = Reader.getFileManager();
1898     ModuleMap &ModMap =
1899         Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1900
1901     std::string Filename = key.Filename;
1902     if (key.Imported)
1903       Reader.ResolveImportedPath(M, Filename);
1904     // FIXME: This is not always the right filename-as-written, but we're not
1905     // going to use this information to rebuild the module, so it doesn't make
1906     // a lot of difference.
1907     Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1908     ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1909     HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1910   }
1911
1912   // This HeaderFileInfo was externally loaded.
1913   HFI.External = true;
1914   HFI.IsValid = true;
1915   return HFI;
1916 }
1917
1918 void ASTReader::addPendingMacro(IdentifierInfo *II,
1919                                 ModuleFile *M,
1920                                 uint64_t MacroDirectivesOffset) {
1921   assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1922   PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1923 }
1924
1925 void ASTReader::ReadDefinedMacros() {
1926   // Note that we are loading defined macros.
1927   Deserializing Macros(this);
1928
1929   for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1930     BitstreamCursor &MacroCursor = I.MacroCursor;
1931
1932     // If there was no preprocessor block, skip this file.
1933     if (MacroCursor.getBitcodeBytes().empty())
1934       continue;
1935
1936     BitstreamCursor Cursor = MacroCursor;
1937     if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
1938       Error(std::move(Err));
1939       return;
1940     }
1941
1942     RecordData Record;
1943     while (true) {
1944       Expected<llvm::BitstreamEntry> MaybeE = Cursor.advanceSkippingSubblocks();
1945       if (!MaybeE) {
1946         Error(MaybeE.takeError());
1947         return;
1948       }
1949       llvm::BitstreamEntry E = MaybeE.get();
1950
1951       switch (E.Kind) {
1952       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1953       case llvm::BitstreamEntry::Error:
1954         Error("malformed block record in AST file");
1955         return;
1956       case llvm::BitstreamEntry::EndBlock:
1957         goto NextCursor;
1958
1959       case llvm::BitstreamEntry::Record: {
1960         Record.clear();
1961         Expected<unsigned> MaybeRecord = Cursor.readRecord(E.ID, Record);
1962         if (!MaybeRecord) {
1963           Error(MaybeRecord.takeError());
1964           return;
1965         }
1966         switch (MaybeRecord.get()) {
1967         default:  // Default behavior: ignore.
1968           break;
1969
1970         case PP_MACRO_OBJECT_LIKE:
1971         case PP_MACRO_FUNCTION_LIKE: {
1972           IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1973           if (II->isOutOfDate())
1974             updateOutOfDateIdentifier(*II);
1975           break;
1976         }
1977
1978         case PP_TOKEN:
1979           // Ignore tokens.
1980           break;
1981         }
1982         break;
1983       }
1984       }
1985     }
1986     NextCursor:  ;
1987   }
1988 }
1989
1990 namespace {
1991
1992   /// Visitor class used to look up identifirs in an AST file.
1993   class IdentifierLookupVisitor {
1994     StringRef Name;
1995     unsigned NameHash;
1996     unsigned PriorGeneration;
1997     unsigned &NumIdentifierLookups;
1998     unsigned &NumIdentifierLookupHits;
1999     IdentifierInfo *Found = nullptr;
2000
2001   public:
2002     IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
2003                             unsigned &NumIdentifierLookups,
2004                             unsigned &NumIdentifierLookupHits)
2005       : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
2006         PriorGeneration(PriorGeneration),
2007         NumIdentifierLookups(NumIdentifierLookups),
2008         NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2009
2010     bool operator()(ModuleFile &M) {
2011       // If we've already searched this module file, skip it now.
2012       if (M.Generation <= PriorGeneration)
2013         return true;
2014
2015       ASTIdentifierLookupTable *IdTable
2016         = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
2017       if (!IdTable)
2018         return false;
2019
2020       ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
2021                                      Found);
2022       ++NumIdentifierLookups;
2023       ASTIdentifierLookupTable::iterator Pos =
2024           IdTable->find_hashed(Name, NameHash, &Trait);
2025       if (Pos == IdTable->end())
2026         return false;
2027
2028       // Dereferencing the iterator has the effect of building the
2029       // IdentifierInfo node and populating it with the various
2030       // declarations it needs.
2031       ++NumIdentifierLookupHits;
2032       Found = *Pos;
2033       return true;
2034     }
2035
2036     // Retrieve the identifier info found within the module
2037     // files.
2038     IdentifierInfo *getIdentifierInfo() const { return Found; }
2039   };
2040
2041 } // namespace
2042
2043 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
2044   // Note that we are loading an identifier.
2045   Deserializing AnIdentifier(this);
2046
2047   unsigned PriorGeneration = 0;
2048   if (getContext().getLangOpts().Modules)
2049     PriorGeneration = IdentifierGeneration[&II];
2050
2051   // If there is a global index, look there first to determine which modules
2052   // provably do not have any results for this identifier.
2053   GlobalModuleIndex::HitSet Hits;
2054   GlobalModuleIndex::HitSet *HitsPtr = nullptr;
2055   if (!loadGlobalIndex()) {
2056     if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
2057       HitsPtr = &Hits;
2058     }
2059   }
2060
2061   IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
2062                                   NumIdentifierLookups,
2063                                   NumIdentifierLookupHits);
2064   ModuleMgr.visit(Visitor, HitsPtr);
2065   markIdentifierUpToDate(&II);
2066 }
2067
2068 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
2069   if (!II)
2070     return;
2071
2072   II->setOutOfDate(false);
2073
2074   // Update the generation for this identifier.
2075   if (getContext().getLangOpts().Modules)
2076     IdentifierGeneration[II] = getGeneration();
2077 }
2078
2079 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
2080                                     const PendingMacroInfo &PMInfo) {
2081   ModuleFile &M = *PMInfo.M;
2082
2083   BitstreamCursor &Cursor = M.MacroCursor;
2084   SavedStreamPosition SavedPosition(Cursor);
2085   if (llvm::Error Err = Cursor.JumpToBit(PMInfo.MacroDirectivesOffset)) {
2086     Error(std::move(Err));
2087     return;
2088   }
2089
2090   struct ModuleMacroRecord {
2091     SubmoduleID SubModID;
2092     MacroInfo *MI;
2093     SmallVector<SubmoduleID, 8> Overrides;
2094   };
2095   llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
2096
2097   // We expect to see a sequence of PP_MODULE_MACRO records listing exported
2098   // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
2099   // macro histroy.
2100   RecordData Record;
2101   while (true) {
2102     Expected<llvm::BitstreamEntry> MaybeEntry =
2103         Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2104     if (!MaybeEntry) {
2105       Error(MaybeEntry.takeError());
2106       return;
2107     }
2108     llvm::BitstreamEntry Entry = MaybeEntry.get();
2109
2110     if (Entry.Kind != llvm::BitstreamEntry::Record) {
2111       Error("malformed block record in AST file");
2112       return;
2113     }
2114
2115     Record.clear();
2116     Expected<unsigned> MaybePP = Cursor.readRecord(Entry.ID, Record);
2117     if (!MaybePP) {
2118       Error(MaybePP.takeError());
2119       return;
2120     }
2121     switch ((PreprocessorRecordTypes)MaybePP.get()) {
2122     case PP_MACRO_DIRECTIVE_HISTORY:
2123       break;
2124
2125     case PP_MODULE_MACRO: {
2126       ModuleMacros.push_back(ModuleMacroRecord());
2127       auto &Info = ModuleMacros.back();
2128       Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2129       Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2130       for (int I = 2, N = Record.size(); I != N; ++I)
2131         Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2132       continue;
2133     }
2134
2135     default:
2136       Error("malformed block record in AST file");
2137       return;
2138     }
2139
2140     // We found the macro directive history; that's the last record
2141     // for this macro.
2142     break;
2143   }
2144
2145   // Module macros are listed in reverse dependency order.
2146   {
2147     std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2148     llvm::SmallVector<ModuleMacro*, 8> Overrides;
2149     for (auto &MMR : ModuleMacros) {
2150       Overrides.clear();
2151       for (unsigned ModID : MMR.Overrides) {
2152         Module *Mod = getSubmodule(ModID);
2153         auto *Macro = PP.getModuleMacro(Mod, II);
2154         assert(Macro && "missing definition for overridden macro");
2155         Overrides.push_back(Macro);
2156       }
2157
2158       bool Inserted = false;
2159       Module *Owner = getSubmodule(MMR.SubModID);
2160       PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2161     }
2162   }
2163
2164   // Don't read the directive history for a module; we don't have anywhere
2165   // to put it.
2166   if (M.isModule())
2167     return;
2168
2169   // Deserialize the macro directives history in reverse source-order.
2170   MacroDirective *Latest = nullptr, *Earliest = nullptr;
2171   unsigned Idx = 0, N = Record.size();
2172   while (Idx < N) {
2173     MacroDirective *MD = nullptr;
2174     SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2175     MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2176     switch (K) {
2177     case MacroDirective::MD_Define: {
2178       MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2179       MD = PP.AllocateDefMacroDirective(MI, Loc);
2180       break;
2181     }
2182     case MacroDirective::MD_Undefine:
2183       MD = PP.AllocateUndefMacroDirective(Loc);
2184       break;
2185     case MacroDirective::MD_Visibility:
2186       bool isPublic = Record[Idx++];
2187       MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2188       break;
2189     }
2190
2191     if (!Latest)
2192       Latest = MD;
2193     if (Earliest)
2194       Earliest->setPrevious(MD);
2195     Earliest = MD;
2196   }
2197
2198   if (Latest)
2199     PP.setLoadedMacroDirective(II, Earliest, Latest);
2200 }
2201
2202 ASTReader::InputFileInfo
2203 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2204   // Go find this input file.
2205   BitstreamCursor &Cursor = F.InputFilesCursor;
2206   SavedStreamPosition SavedPosition(Cursor);
2207   if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2208     // FIXME this drops errors on the floor.
2209     consumeError(std::move(Err));
2210   }
2211
2212   Expected<unsigned> MaybeCode = Cursor.ReadCode();
2213   if (!MaybeCode) {
2214     // FIXME this drops errors on the floor.
2215     consumeError(MaybeCode.takeError());
2216   }
2217   unsigned Code = MaybeCode.get();
2218   RecordData Record;
2219   StringRef Blob;
2220
2221   if (Expected<unsigned> Maybe = Cursor.readRecord(Code, Record, &Blob))
2222     assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE &&
2223            "invalid record type for input file");
2224   else {
2225     // FIXME this drops errors on the floor.
2226     consumeError(Maybe.takeError());
2227   }
2228
2229   assert(Record[0] == ID && "Bogus stored ID or offset");
2230   InputFileInfo R;
2231   R.StoredSize = static_cast<off_t>(Record[1]);
2232   R.StoredTime = static_cast<time_t>(Record[2]);
2233   R.Overridden = static_cast<bool>(Record[3]);
2234   R.Transient = static_cast<bool>(Record[4]);
2235   R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2236   R.Filename = Blob;
2237   ResolveImportedPath(F, R.Filename);
2238   return R;
2239 }
2240
2241 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2242 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2243   // If this ID is bogus, just return an empty input file.
2244   if (ID == 0 || ID > F.InputFilesLoaded.size())
2245     return InputFile();
2246
2247   // If we've already loaded this input file, return it.
2248   if (F.InputFilesLoaded[ID-1].getFile())
2249     return F.InputFilesLoaded[ID-1];
2250
2251   if (F.InputFilesLoaded[ID-1].isNotFound())
2252     return InputFile();
2253
2254   // Go find this input file.
2255   BitstreamCursor &Cursor = F.InputFilesCursor;
2256   SavedStreamPosition SavedPosition(Cursor);
2257   if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2258     // FIXME this drops errors on the floor.
2259     consumeError(std::move(Err));
2260   }
2261
2262   InputFileInfo FI = readInputFileInfo(F, ID);
2263   off_t StoredSize = FI.StoredSize;
2264   time_t StoredTime = FI.StoredTime;
2265   bool Overridden = FI.Overridden;
2266   bool Transient = FI.Transient;
2267   StringRef Filename = FI.Filename;
2268
2269   const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2270   // If we didn't find the file, resolve it relative to the
2271   // original directory from which this AST file was created.
2272   if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2273       F.OriginalDir != F.BaseDirectory) {
2274     std::string Resolved = resolveFileRelativeToOriginalDir(
2275         Filename, F.OriginalDir, F.BaseDirectory);
2276     if (!Resolved.empty())
2277       File = FileMgr.getFile(Resolved);
2278   }
2279
2280   // For an overridden file, create a virtual file with the stored
2281   // size/timestamp.
2282   if ((Overridden || Transient) && File == nullptr)
2283     File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2284
2285   if (File == nullptr) {
2286     if (Complain) {
2287       std::string ErrorStr = "could not find file '";
2288       ErrorStr += Filename;
2289       ErrorStr += "' referenced by AST file '";
2290       ErrorStr += F.FileName;
2291       ErrorStr += "'";
2292       Error(ErrorStr);
2293     }
2294     // Record that we didn't find the file.
2295     F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2296     return InputFile();
2297   }
2298
2299   // Check if there was a request to override the contents of the file
2300   // that was part of the precompiled header. Overriding such a file
2301   // can lead to problems when lexing using the source locations from the
2302   // PCH.
2303   SourceManager &SM = getSourceManager();
2304   // FIXME: Reject if the overrides are different.
2305   if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2306     if (Complain)
2307       Error(diag::err_fe_pch_file_overridden, Filename);
2308     // After emitting the diagnostic, recover by disabling the override so
2309     // that the original file will be used.
2310     //
2311     // FIXME: This recovery is just as broken as the original state; there may
2312     // be another precompiled module that's using the overridden contents, or
2313     // we might be half way through parsing it. Instead, we should treat the
2314     // overridden contents as belonging to a separate FileEntry.
2315     SM.disableFileContentsOverride(File);
2316     // The FileEntry is a virtual file entry with the size of the contents
2317     // that would override the original contents. Set it to the original's
2318     // size/time.
2319     FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2320                             StoredSize, StoredTime);
2321   }
2322
2323   bool IsOutOfDate = false;
2324
2325   // For an overridden file, there is nothing to validate.
2326   if (!Overridden && //
2327       (StoredSize != File->getSize() ||
2328        (StoredTime && StoredTime != File->getModificationTime() &&
2329         !DisableValidation)
2330        )) {
2331     if (Complain) {
2332       // Build a list of the PCH imports that got us here (in reverse).
2333       SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2334       while (!ImportStack.back()->ImportedBy.empty())
2335         ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2336
2337       // The top-level PCH is stale.
2338       StringRef TopLevelPCHName(ImportStack.back()->FileName);
2339       unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2340       if (DiagnosticKind == 0)
2341         Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2342       else if (DiagnosticKind == 1)
2343         Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2344       else
2345         Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2346
2347       // Print the import stack.
2348       if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2349         Diag(diag::note_pch_required_by)
2350           << Filename << ImportStack[0]->FileName;
2351         for (unsigned I = 1; I < ImportStack.size(); ++I)
2352           Diag(diag::note_pch_required_by)
2353             << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2354       }
2355
2356       if (!Diags.isDiagnosticInFlight())
2357         Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2358     }
2359
2360     IsOutOfDate = true;
2361   }
2362   // FIXME: If the file is overridden and we've already opened it,
2363   // issue an error (or split it into a separate FileEntry).
2364
2365   InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2366
2367   // Note that we've loaded this input file.
2368   F.InputFilesLoaded[ID-1] = IF;
2369   return IF;
2370 }
2371
2372 /// If we are loading a relocatable PCH or module file, and the filename
2373 /// is not an absolute path, add the system or module root to the beginning of
2374 /// the file name.
2375 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2376   // Resolve relative to the base directory, if we have one.
2377   if (!M.BaseDirectory.empty())
2378     return ResolveImportedPath(Filename, M.BaseDirectory);
2379 }
2380
2381 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2382   if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2383     return;
2384
2385   SmallString<128> Buffer;
2386   llvm::sys::path::append(Buffer, Prefix, Filename);
2387   Filename.assign(Buffer.begin(), Buffer.end());
2388 }
2389
2390 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2391   switch (ARR) {
2392   case ASTReader::Failure: return true;
2393   case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2394   case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2395   case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2396   case ASTReader::ConfigurationMismatch:
2397     return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2398   case ASTReader::HadErrors: return true;
2399   case ASTReader::Success: return false;
2400   }
2401
2402   llvm_unreachable("unknown ASTReadResult");
2403 }
2404
2405 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2406     BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2407     bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2408     std::string &SuggestedPredefines) {
2409   if (llvm::Error Err = Stream.EnterSubBlock(OPTIONS_BLOCK_ID)) {
2410     // FIXME this drops errors on the floor.
2411     consumeError(std::move(Err));
2412     return Failure;
2413   }
2414
2415   // Read all of the records in the options block.
2416   RecordData Record;
2417   ASTReadResult Result = Success;
2418   while (true) {
2419     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2420     if (!MaybeEntry) {
2421       // FIXME this drops errors on the floor.
2422       consumeError(MaybeEntry.takeError());
2423       return Failure;
2424     }
2425     llvm::BitstreamEntry Entry = MaybeEntry.get();
2426
2427     switch (Entry.Kind) {
2428     case llvm::BitstreamEntry::Error:
2429     case llvm::BitstreamEntry::SubBlock:
2430       return Failure;
2431
2432     case llvm::BitstreamEntry::EndBlock:
2433       return Result;
2434
2435     case llvm::BitstreamEntry::Record:
2436       // The interesting case.
2437       break;
2438     }
2439
2440     // Read and process a record.
2441     Record.clear();
2442     Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
2443     if (!MaybeRecordType) {
2444       // FIXME this drops errors on the floor.
2445       consumeError(MaybeRecordType.takeError());
2446       return Failure;
2447     }
2448     switch ((OptionsRecordTypes)MaybeRecordType.get()) {
2449     case LANGUAGE_OPTIONS: {
2450       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2451       if (ParseLanguageOptions(Record, Complain, Listener,
2452                                AllowCompatibleConfigurationMismatch))
2453         Result = ConfigurationMismatch;
2454       break;
2455     }
2456
2457     case TARGET_OPTIONS: {
2458       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2459       if (ParseTargetOptions(Record, Complain, Listener,
2460                              AllowCompatibleConfigurationMismatch))
2461         Result = ConfigurationMismatch;
2462       break;
2463     }
2464
2465     case FILE_SYSTEM_OPTIONS: {
2466       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2467       if (!AllowCompatibleConfigurationMismatch &&
2468           ParseFileSystemOptions(Record, Complain, Listener))
2469         Result = ConfigurationMismatch;
2470       break;
2471     }
2472
2473     case HEADER_SEARCH_OPTIONS: {
2474       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2475       if (!AllowCompatibleConfigurationMismatch &&
2476           ParseHeaderSearchOptions(Record, Complain, Listener))
2477         Result = ConfigurationMismatch;
2478       break;
2479     }
2480
2481     case PREPROCESSOR_OPTIONS:
2482       bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2483       if (!AllowCompatibleConfigurationMismatch &&
2484           ParsePreprocessorOptions(Record, Complain, Listener,
2485                                    SuggestedPredefines))
2486         Result = ConfigurationMismatch;
2487       break;
2488     }
2489   }
2490 }
2491
2492 ASTReader::ASTReadResult
2493 ASTReader::ReadControlBlock(ModuleFile &F,
2494                             SmallVectorImpl<ImportedModule> &Loaded,
2495                             const ModuleFile *ImportedBy,
2496                             unsigned ClientLoadCapabilities) {
2497   BitstreamCursor &Stream = F.Stream;
2498   ASTReadResult Result = Success;
2499
2500   if (llvm::Error Err = Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2501     Error(std::move(Err));
2502     return Failure;
2503   }
2504
2505   // Lambda to read the unhashed control block the first time it's called.
2506   //
2507   // For PCM files, the unhashed control block cannot be read until after the
2508   // MODULE_NAME record.  However, PCH files have no MODULE_NAME, and yet still
2509   // need to look ahead before reading the IMPORTS record.  For consistency,
2510   // this block is always read somehow (see BitstreamEntry::EndBlock).
2511   bool HasReadUnhashedControlBlock = false;
2512   auto readUnhashedControlBlockOnce = [&]() {
2513     if (!HasReadUnhashedControlBlock) {
2514       HasReadUnhashedControlBlock = true;
2515       if (ASTReadResult Result =
2516               readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2517         return Result;
2518     }
2519     return Success;
2520   };
2521
2522   // Read all of the records and blocks in the control block.
2523   RecordData Record;
2524   unsigned NumInputs = 0;
2525   unsigned NumUserInputs = 0;
2526   StringRef BaseDirectoryAsWritten;
2527   while (true) {
2528     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2529     if (!MaybeEntry) {
2530       Error(MaybeEntry.takeError());
2531       return Failure;
2532     }
2533     llvm::BitstreamEntry Entry = MaybeEntry.get();
2534
2535     switch (Entry.Kind) {
2536     case llvm::BitstreamEntry::Error:
2537       Error("malformed block record in AST file");
2538       return Failure;
2539     case llvm::BitstreamEntry::EndBlock: {
2540       // Validate the module before returning.  This call catches an AST with
2541       // no module name and no imports.
2542       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2543         return Result;
2544
2545       // Validate input files.
2546       const HeaderSearchOptions &HSOpts =
2547           PP.getHeaderSearchInfo().getHeaderSearchOpts();
2548
2549       // All user input files reside at the index range [0, NumUserInputs), and
2550       // system input files reside at [NumUserInputs, NumInputs). For explicitly
2551       // loaded module files, ignore missing inputs.
2552       if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2553           F.Kind != MK_PrebuiltModule) {
2554         bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2555
2556         // If we are reading a module, we will create a verification timestamp,
2557         // so we verify all input files.  Otherwise, verify only user input
2558         // files.
2559
2560         unsigned N = NumUserInputs;
2561         if (ValidateSystemInputs ||
2562             (HSOpts.ModulesValidateOncePerBuildSession &&
2563              F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2564              F.Kind == MK_ImplicitModule))
2565           N = NumInputs;
2566
2567         for (unsigned I = 0; I < N; ++I) {
2568           InputFile IF = getInputFile(F, I+1, Complain);
2569           if (!IF.getFile() || IF.isOutOfDate())
2570             return OutOfDate;
2571         }
2572       }
2573
2574       if (Listener)
2575         Listener->visitModuleFile(F.FileName, F.Kind);
2576
2577       if (Listener && Listener->needsInputFileVisitation()) {
2578         unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2579                                                                 : NumUserInputs;
2580         for (unsigned I = 0; I < N; ++I) {
2581           bool IsSystem = I >= NumUserInputs;
2582           InputFileInfo FI = readInputFileInfo(F, I+1);
2583           Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2584                                    F.Kind == MK_ExplicitModule ||
2585                                    F.Kind == MK_PrebuiltModule);
2586         }
2587       }
2588
2589       return Result;
2590     }
2591
2592     case llvm::BitstreamEntry::SubBlock:
2593       switch (Entry.ID) {
2594       case INPUT_FILES_BLOCK_ID:
2595         F.InputFilesCursor = Stream;
2596         if (llvm::Error Err = Stream.SkipBlock()) {
2597           Error(std::move(Err));
2598           return Failure;
2599         }
2600         if (ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2601           Error("malformed block record in AST file");
2602           return Failure;
2603         }
2604         continue;
2605
2606       case OPTIONS_BLOCK_ID:
2607         // If we're reading the first module for this group, check its options
2608         // are compatible with ours. For modules it imports, no further checking
2609         // is required, because we checked them when we built it.
2610         if (Listener && !ImportedBy) {
2611           // Should we allow the configuration of the module file to differ from
2612           // the configuration of the current translation unit in a compatible
2613           // way?
2614           //
2615           // FIXME: Allow this for files explicitly specified with -include-pch.
2616           bool AllowCompatibleConfigurationMismatch =
2617               F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2618
2619           Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2620                                     AllowCompatibleConfigurationMismatch,
2621                                     *Listener, SuggestedPredefines);
2622           if (Result == Failure) {
2623             Error("malformed block record in AST file");
2624             return Result;
2625           }
2626
2627           if (DisableValidation ||
2628               (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2629             Result = Success;
2630
2631           // If we can't load the module, exit early since we likely
2632           // will rebuild the module anyway. The stream may be in the
2633           // middle of a block.
2634           if (Result != Success)
2635             return Result;
2636         } else if (llvm::Error Err = Stream.SkipBlock()) {
2637           Error(std::move(Err));
2638           return Failure;
2639         }
2640         continue;
2641
2642       default:
2643         if (llvm::Error Err = Stream.SkipBlock()) {
2644           Error(std::move(Err));
2645           return Failure;
2646         }
2647         continue;
2648       }
2649
2650     case llvm::BitstreamEntry::Record:
2651       // The interesting case.
2652       break;
2653     }
2654
2655     // Read and process a record.
2656     Record.clear();
2657     StringRef Blob;
2658     Expected<unsigned> MaybeRecordType =
2659         Stream.readRecord(Entry.ID, Record, &Blob);
2660     if (!MaybeRecordType) {
2661       Error(MaybeRecordType.takeError());
2662       return Failure;
2663     }
2664     switch ((ControlRecordTypes)MaybeRecordType.get()) {
2665     case METADATA: {
2666       if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2667         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2668           Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2669                                         : diag::err_pch_version_too_new);
2670         return VersionMismatch;
2671       }
2672
2673       bool hasErrors = Record[7];
2674       if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2675         Diag(diag::err_pch_with_compiler_errors);
2676         return HadErrors;
2677       }
2678       if (hasErrors) {
2679         Diags.ErrorOccurred = true;
2680         Diags.UncompilableErrorOccurred = true;
2681         Diags.UnrecoverableErrorOccurred = true;
2682       }
2683
2684       F.RelocatablePCH = Record[4];
2685       // Relative paths in a relocatable PCH are relative to our sysroot.
2686       if (F.RelocatablePCH)
2687         F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2688
2689       F.HasTimestamps = Record[5];
2690
2691       F.PCHHasObjectFile = Record[6];
2692
2693       const std::string &CurBranch = getClangFullRepositoryVersion();
2694       StringRef ASTBranch = Blob;
2695       if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2696         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2697           Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2698         return VersionMismatch;
2699       }
2700       break;
2701     }
2702
2703     case IMPORTS: {
2704       // Validate the AST before processing any imports (otherwise, untangling
2705       // them can be error-prone and expensive).  A module will have a name and
2706       // will already have been validated, but this catches the PCH case.
2707       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2708         return Result;
2709
2710       // Load each of the imported PCH files.
2711       unsigned Idx = 0, N = Record.size();
2712       while (Idx < N) {
2713         // Read information about the AST file.
2714         ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2715         // The import location will be the local one for now; we will adjust
2716         // all import locations of module imports after the global source
2717         // location info are setup, in ReadAST.
2718         SourceLocation ImportLoc =
2719             ReadUntranslatedSourceLocation(Record[Idx++]);
2720         off_t StoredSize = (off_t)Record[Idx++];
2721         time_t StoredModTime = (time_t)Record[Idx++];
2722         ASTFileSignature StoredSignature = {
2723             {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2724               (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2725               (uint32_t)Record[Idx++]}}};
2726
2727         std::string ImportedName = ReadString(Record, Idx);
2728         std::string ImportedFile;
2729
2730         // For prebuilt and explicit modules first consult the file map for
2731         // an override. Note that here we don't search prebuilt module
2732         // directories, only the explicit name to file mappings. Also, we will
2733         // still verify the size/signature making sure it is essentially the
2734         // same file but perhaps in a different location.
2735         if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2736           ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2737             ImportedName, /*FileMapOnly*/ true);
2738
2739         if (ImportedFile.empty())
2740           // Use BaseDirectoryAsWritten to ensure we use the same path in the
2741           // ModuleCache as when writing.
2742           ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2743         else
2744           SkipPath(Record, Idx);
2745
2746         // If our client can't cope with us being out of date, we can't cope with
2747         // our dependency being missing.
2748         unsigned Capabilities = ClientLoadCapabilities;
2749         if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2750           Capabilities &= ~ARR_Missing;
2751
2752         // Load the AST file.
2753         auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2754                                   Loaded, StoredSize, StoredModTime,
2755                                   StoredSignature, Capabilities);
2756
2757         // If we diagnosed a problem, produce a backtrace.
2758         if (isDiagnosedResult(Result, Capabilities))
2759           Diag(diag::note_module_file_imported_by)
2760               << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2761
2762         switch (Result) {
2763         case Failure: return Failure;
2764           // If we have to ignore the dependency, we'll have to ignore this too.
2765         case Missing:
2766         case OutOfDate: return OutOfDate;
2767         case VersionMismatch: return VersionMismatch;
2768         case ConfigurationMismatch: return ConfigurationMismatch;
2769         case HadErrors: return HadErrors;
2770         case Success: break;
2771         }
2772       }
2773       break;
2774     }
2775
2776     case ORIGINAL_FILE:
2777       F.OriginalSourceFileID = FileID::get(Record[0]);
2778       F.ActualOriginalSourceFileName = Blob;
2779       F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2780       ResolveImportedPath(F, F.OriginalSourceFileName);
2781       break;
2782
2783     case ORIGINAL_FILE_ID:
2784       F.OriginalSourceFileID = FileID::get(Record[0]);
2785       break;
2786
2787     case ORIGINAL_PCH_DIR:
2788       F.OriginalDir = Blob;
2789       break;
2790
2791     case MODULE_NAME:
2792       F.ModuleName = Blob;
2793       Diag(diag::remark_module_import)
2794           << F.ModuleName << F.FileName << (ImportedBy ? true : false)
2795           << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
2796       if (Listener)
2797         Listener->ReadModuleName(F.ModuleName);
2798
2799       // Validate the AST as soon as we have a name so we can exit early on
2800       // failure.
2801       if (ASTReadResult Result = readUnhashedControlBlockOnce())
2802         return Result;
2803
2804       break;
2805
2806     case MODULE_DIRECTORY: {
2807       // Save the BaseDirectory as written in the PCM for computing the module
2808       // filename for the ModuleCache.
2809       BaseDirectoryAsWritten = Blob;
2810       assert(!F.ModuleName.empty() &&
2811              "MODULE_DIRECTORY found before MODULE_NAME");
2812       // If we've already loaded a module map file covering this module, we may
2813       // have a better path for it (relative to the current build).
2814       Module *M = PP.getHeaderSearchInfo().lookupModule(
2815           F.ModuleName, /*AllowSearch*/ true,
2816           /*AllowExtraModuleMapSearch*/ true);
2817       if (M && M->Directory) {
2818         // If we're implicitly loading a module, the base directory can't
2819         // change between the build and use.
2820         // Don't emit module relocation error if we have -fno-validate-pch
2821         if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2822             F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2823           const DirectoryEntry *BuildDir =
2824               PP.getFileManager().getDirectory(Blob);
2825           if (!BuildDir || BuildDir != M->Directory) {
2826             if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2827               Diag(diag::err_imported_module_relocated)
2828                   << F.ModuleName << Blob << M->Directory->getName();
2829             return OutOfDate;
2830           }
2831         }
2832         F.BaseDirectory = M->Directory->getName();
2833       } else {
2834         F.BaseDirectory = Blob;
2835       }
2836       break;
2837     }
2838
2839     case MODULE_MAP_FILE:
2840       if (ASTReadResult Result =
2841               ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2842         return Result;
2843       break;
2844
2845     case INPUT_FILE_OFFSETS:
2846       NumInputs = Record[0];
2847       NumUserInputs = Record[1];
2848       F.InputFileOffsets =
2849           (const llvm::support::unaligned_uint64_t *)Blob.data();
2850       F.InputFilesLoaded.resize(NumInputs);
2851       F.NumUserInputFiles = NumUserInputs;
2852       break;
2853     }
2854   }
2855 }
2856
2857 ASTReader::ASTReadResult
2858 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2859   BitstreamCursor &Stream = F.Stream;
2860
2861   if (llvm::Error Err = Stream.EnterSubBlock(AST_BLOCK_ID)) {
2862     Error(std::move(Err));
2863     return Failure;
2864   }
2865
2866   // Read all of the records and blocks for the AST file.
2867   RecordData Record;
2868   while (true) {
2869     Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2870     if (!MaybeEntry) {
2871       Error(MaybeEntry.takeError());
2872       return Failure;
2873     }
2874     llvm::BitstreamEntry Entry = MaybeEntry.get();
2875
2876     switch (Entry.Kind) {
2877     case llvm::BitstreamEntry::Error:
2878       Error("error at end of module block in AST file");
2879       return Failure;
2880     case llvm::BitstreamEntry::EndBlock:
2881       // Outside of C++, we do not store a lookup map for the translation unit.
2882       // Instead, mark it as needing a lookup map to be built if this module
2883       // contains any declarations lexically within it (which it always does!).
2884       // This usually has no cost, since we very rarely need the lookup map for
2885       // the translation unit outside C++.
2886       if (ASTContext *Ctx = ContextObj) {
2887         DeclContext *DC = Ctx->getTranslationUnitDecl();
2888         if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2889           DC->setMustBuildLookupTable();
2890       }
2891
2892       return Success;
2893     case llvm::BitstreamEntry::SubBlock:
2894       switch (Entry.ID) {
2895       case DECLTYPES_BLOCK_ID:
2896         // We lazily load the decls block, but we want to set up the
2897         // DeclsCursor cursor to point into it.  Clone our current bitcode
2898         // cursor to it, enter the block and read the abbrevs in that block.
2899         // With the main cursor, we just skip over it.
2900         F.DeclsCursor = Stream;
2901         if (llvm::Error Err = Stream.SkipBlock()) {
2902           Error(std::move(Err));
2903           return Failure;
2904         }
2905         if (ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2906           Error("malformed block record in AST file");
2907           return Failure;
2908         }
2909         break;
2910
2911       case PREPROCESSOR_BLOCK_ID:
2912         F.MacroCursor = Stream;
2913         if (!PP.getExternalSource())
2914           PP.setExternalSource(this);
2915
2916         if (llvm::Error Err = Stream.SkipBlock()) {
2917           Error(std::move(Err));
2918           return Failure;
2919         }
2920         if (ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2921           Error("malformed block record in AST file");
2922           return Failure;
2923         }
2924         F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2925         break;
2926
2927       case PREPROCESSOR_DETAIL_BLOCK_ID:
2928         F.PreprocessorDetailCursor = Stream;
2929
2930         if (llvm::Error Err = Stream.SkipBlock()) {
2931           Error(std::move(Err));
2932           return Failure;
2933         }
2934         if (ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2935                              PREPROCESSOR_DETAIL_BLOCK_ID)) {
2936           Error("malformed preprocessor detail record in AST file");
2937           return Failure;
2938         }
2939         F.PreprocessorDetailStartOffset
2940         = F.PreprocessorDetailCursor.GetCurrentBitNo();
2941
2942         if (!PP.getPreprocessingRecord())
2943           PP.createPreprocessingRecord();
2944         if (!PP.getPreprocessingRecord()->getExternalSource())
2945           PP.getPreprocessingRecord()->SetExternalSource(*this);
2946         break;
2947
2948       case SOURCE_MANAGER_BLOCK_ID:
2949         if (ReadSourceManagerBlock(F))
2950           return Failure;
2951         break;
2952
2953       case SUBMODULE_BLOCK_ID:
2954         if (ASTReadResult Result =
2955                 ReadSubmoduleBlock(F, ClientLoadCapabilities))
2956           return Result;
2957         break;
2958
2959       case COMMENTS_BLOCK_ID: {
2960         BitstreamCursor C = Stream;
2961
2962         if (llvm::Error Err = Stream.SkipBlock()) {
2963           Error(std::move(Err));
2964           return Failure;
2965         }
2966         if (ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2967           Error("malformed comments block in AST file");
2968           return Failure;
2969         }
2970         CommentsCursors.push_back(std::make_pair(C, &F));
2971         break;
2972       }
2973
2974       default:
2975         if (llvm::Error Err = Stream.SkipBlock()) {
2976           Error(std::move(Err));
2977           return Failure;
2978         }
2979         break;
2980       }
2981       continue;
2982
2983     case llvm::BitstreamEntry::Record:
2984       // The interesting case.
2985       break;
2986     }
2987
2988     // Read and process a record.
2989     Record.clear();
2990     StringRef Blob;
2991     Expected<unsigned> MaybeRecordType =
2992         Stream.readRecord(Entry.ID, Record, &Blob);
2993     if (!MaybeRecordType) {
2994       Error(MaybeRecordType.takeError());
2995       return Failure;
2996     }
2997     ASTRecordTypes RecordType = (ASTRecordTypes)MaybeRecordType.get();
2998
2999     // If we're not loading an AST context, we don't care about most records.
3000     if (!ContextObj) {
3001       switch (RecordType) {
3002       case IDENTIFIER_TABLE:
3003       case IDENTIFIER_OFFSET:
3004       case INTERESTING_IDENTIFIERS:
3005       case STATISTICS:
3006       case PP_CONDITIONAL_STACK:
3007       case PP_COUNTER_VALUE:
3008       case SOURCE_LOCATION_OFFSETS:
3009       case MODULE_OFFSET_MAP:
3010       case SOURCE_MANAGER_LINE_TABLE:
3011       case SOURCE_LOCATION_PRELOADS:
3012       case PPD_ENTITIES_OFFSETS:
3013       case HEADER_SEARCH_TABLE:
3014       case IMPORTED_MODULES:
3015       case MACRO_OFFSET:
3016         break;
3017       default:
3018         continue;
3019       }
3020     }
3021
3022     switch (RecordType) {
3023     default:  // Default behavior: ignore.
3024       break;
3025
3026     case TYPE_OFFSET: {
3027       if (F.LocalNumTypes != 0) {
3028         Error("duplicate TYPE_OFFSET record in AST file");
3029         return Failure;
3030       }
3031       F.TypeOffsets = (const uint32_t *)Blob.data();
3032       F.LocalNumTypes = Record[0];
3033       unsigned LocalBaseTypeIndex = Record[1];
3034       F.BaseTypeIndex = getTotalNumTypes();
3035
3036       if (F.LocalNumTypes > 0) {
3037         // Introduce the global -> local mapping for types within this module.
3038         GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3039
3040         // Introduce the local -> global mapping for types within this module.
3041         F.TypeRemap.insertOrReplace(
3042           std::make_pair(LocalBaseTypeIndex,
3043                          F.BaseTypeIndex - LocalBaseTypeIndex));
3044
3045         TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
3046       }
3047       break;
3048     }
3049
3050     case DECL_OFFSET: {
3051       if (F.LocalNumDecls != 0) {
3052         Error("duplicate DECL_OFFSET record in AST file");
3053         return Failure;
3054       }
3055       F.DeclOffsets = (const DeclOffset *)Blob.data();
3056       F.LocalNumDecls = Record[0];
3057       unsigned LocalBaseDeclID = Record[1];
3058       F.BaseDeclID = getTotalNumDecls();
3059
3060       if (F.LocalNumDecls > 0) {
3061         // Introduce the global -> local mapping for declarations within this
3062         // module.
3063         GlobalDeclMap.insert(
3064           std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
3065
3066         // Introduce the local -> global mapping for declarations within this
3067         // module.
3068         F.DeclRemap.insertOrReplace(
3069           std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
3070
3071         // Introduce the global -> local mapping for declarations within this
3072         // module.
3073         F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
3074
3075         DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
3076       }
3077       break;
3078     }
3079
3080     case TU_UPDATE_LEXICAL: {
3081       DeclContext *TU = ContextObj->getTranslationUnitDecl();
3082       LexicalContents Contents(
3083           reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
3084               Blob.data()),
3085           static_cast<unsigned int>(Blob.size() / 4));
3086       TULexicalDecls.push_back(std::make_pair(&F, Contents));
3087       TU->setHasExternalLexicalStorage(true);
3088       break;
3089     }
3090
3091     case UPDATE_VISIBLE: {
3092       unsigned Idx = 0;
3093       serialization::DeclID ID = ReadDeclID(F, Record, Idx);
3094       auto *Data = (const unsigned char*)Blob.data();
3095       PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
3096       // If we've already loaded the decl, perform the updates when we finish
3097       // loading this block.
3098       if (Decl *D = GetExistingDecl(ID))
3099         PendingUpdateRecords.push_back(
3100             PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3101       break;
3102     }
3103
3104     case IDENTIFIER_TABLE:
3105       F.IdentifierTableData = Blob.data();
3106       if (Record[0]) {
3107         F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
3108             (const unsigned char *)F.IdentifierTableData + Record[0],
3109             (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
3110             (const unsigned char *)F.IdentifierTableData,
3111             ASTIdentifierLookupTrait(*this, F));
3112
3113         PP.getIdentifierTable().setExternalIdentifierLookup(this);
3114       }
3115       break;
3116
3117     case IDENTIFIER_OFFSET: {
3118       if (F.LocalNumIdentifiers != 0) {
3119         Error("duplicate IDENTIFIER_OFFSET record in AST file");
3120         return Failure;
3121       }
3122       F.IdentifierOffsets = (const uint32_t *)Blob.data();
3123       F.LocalNumIdentifiers = Record[0];
3124       unsigned LocalBaseIdentifierID = Record[1];
3125       F.BaseIdentifierID = getTotalNumIdentifiers();
3126
3127       if (F.LocalNumIdentifiers > 0) {
3128         // Introduce the global -> local mapping for identifiers within this
3129         // module.
3130         GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3131                                                   &F));
3132
3133         // Introduce the local -> global mapping for identifiers within this
3134         // module.
3135         F.IdentifierRemap.insertOrReplace(
3136           std::make_pair(LocalBaseIdentifierID,
3137                          F.BaseIdentifierID - LocalBaseIdentifierID));
3138
3139         IdentifiersLoaded.resize(IdentifiersLoaded.size()
3140                                  + F.LocalNumIdentifiers);
3141       }
3142       break;
3143     }
3144
3145     case INTERESTING_IDENTIFIERS:
3146       F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
3147       break;
3148
3149     case EAGERLY_DESERIALIZED_DECLS:
3150       // FIXME: Skip reading this record if our ASTConsumer doesn't care
3151       // about "interesting" decls (for instance, if we're building a module).
3152       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3153         EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3154       break;
3155
3156     case MODULAR_CODEGEN_DECLS:
3157       // FIXME: Skip reading this record if our ASTConsumer doesn't care about
3158       // them (ie: if we're not codegenerating this module).
3159       if (F.Kind == MK_MainFile)
3160         for (unsigned I = 0, N = Record.size(); I != N; ++I)
3161           EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3162       break;
3163
3164     case SPECIAL_TYPES:
3165       if (SpecialTypes.empty()) {
3166         for (unsigned I = 0, N = Record.size(); I != N; ++I)
3167           SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3168         break;
3169       }
3170
3171       if (SpecialTypes.size() != Record.size()) {
3172         Error("invalid special-types record");
3173         return Failure;
3174       }
3175
3176       for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3177         serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
3178         if (!SpecialTypes[I])
3179           SpecialTypes[I] = ID;
3180         // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
3181         // merge step?
3182       }
3183       break;
3184
3185     case STATISTICS:
3186       TotalNumStatements += Record[0];
3187       TotalNumMacros += Record[1];
3188       TotalLexicalDeclContexts += Record[2];
3189       TotalVisibleDeclContexts += Record[3];
3190       break;
3191
3192     case UNUSED_FILESCOPED_DECLS:
3193       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3194         UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3195       break;
3196
3197     case DELEGATING_CTORS:
3198       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3199         DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3200       break;
3201
3202     case WEAK_UNDECLARED_IDENTIFIERS:
3203       if (Record.size() % 4 != 0) {
3204         Error("invalid weak identifiers record");
3205         return Failure;
3206       }
3207
3208       // FIXME: Ignore weak undeclared identifiers from non-original PCH
3209       // files. This isn't the way to do it :)
3210       WeakUndeclaredIdentifiers.clear();
3211
3212       // Translate the weak, undeclared identifiers into global IDs.
3213       for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3214         WeakUndeclaredIdentifiers.push_back(
3215           getGlobalIdentifierID(F, Record[I++]));
3216         WeakUndeclaredIdentifiers.push_back(
3217           getGlobalIdentifierID(F, Record[I++]));
3218         WeakUndeclaredIdentifiers.push_back(
3219           ReadSourceLocation(F, Record, I).getRawEncoding());
3220         WeakUndeclaredIdentifiers.push_back(Record[I++]);
3221       }
3222       break;
3223
3224     case SELECTOR_OFFSETS: {
3225       F.SelectorOffsets = (const uint32_t *)Blob.data();
3226       F.LocalNumSelectors = Record[0];
3227       unsigned LocalBaseSelectorID = Record[1];
3228       F.BaseSelectorID = getTotalNumSelectors();
3229
3230       if (F.LocalNumSelectors > 0) {
3231         // Introduce the global -> local mapping for selectors within this
3232         // module.
3233         GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3234
3235         // Introduce the local -> global mapping for selectors within this
3236         // module.
3237         F.SelectorRemap.insertOrReplace(
3238           std::make_pair(LocalBaseSelectorID,
3239                          F.BaseSelectorID - LocalBaseSelectorID));
3240
3241         SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3242       }
3243       break;
3244     }
3245
3246     case METHOD_POOL:
3247       F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3248       if (Record[0])
3249         F.SelectorLookupTable
3250           = ASTSelectorLookupTable::Create(
3251                         F.SelectorLookupTableData + Record[0],
3252                         F.SelectorLookupTableData,
3253                         ASTSelectorLookupTrait(*this, F));
3254       TotalNumMethodPoolEntries += Record[1];
3255       break;
3256
3257     case REFERENCED_SELECTOR_POOL:
3258       if (!Record.empty()) {
3259         for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3260           ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3261                                                                 Record[Idx++]));
3262           ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3263                                               getRawEncoding());
3264         }
3265       }
3266       break;
3267
3268     case PP_CONDITIONAL_STACK:
3269       if (!Record.empty()) {
3270         unsigned Idx = 0, End = Record.size() - 1;
3271         bool ReachedEOFWhileSkipping = Record[Idx++];
3272         llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3273         if (ReachedEOFWhileSkipping) {
3274           SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3275           SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3276           bool FoundNonSkipPortion = Record[Idx++];
3277           bool FoundElse = Record[Idx++];
3278           SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3279           SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3280                            FoundElse, ElseLoc);
3281         }
3282         SmallVector<PPConditionalInfo, 4> ConditionalStack;
3283         while (Idx < End) {
3284           auto Loc = ReadSourceLocation(F, Record, Idx);
3285           bool WasSkipping = Record[Idx++];
3286           bool FoundNonSkip = Record[Idx++];
3287           bool FoundElse = Record[Idx++];
3288           ConditionalStack.push_back(
3289               {Loc, WasSkipping, FoundNonSkip, FoundElse});
3290         }
3291         PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3292       }
3293       break;
3294
3295     case PP_COUNTER_VALUE:
3296       if (!Record.empty() && Listener)
3297         Listener->ReadCounter(F, Record[0]);
3298       break;
3299
3300     case FILE_SORTED_DECLS:
3301       F.FileSortedDecls = (const DeclID *)Blob.data();
3302       F.NumFileSortedDecls = Record[0];
3303       break;
3304
3305     case SOURCE_LOCATION_OFFSETS: {
3306       F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3307       F.LocalNumSLocEntries = Record[0];
3308       unsigned SLocSpaceSize = Record[1];
3309       std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3310           SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3311                                               SLocSpaceSize);
3312       if (!F.SLocEntryBaseID) {
3313         Error("ran out of source locations");
3314         break;
3315       }
3316       // Make our entry in the range map. BaseID is negative and growing, so
3317       // we invert it. Because we invert it, though, we need the other end of
3318       // the range.
3319       unsigned RangeStart =
3320           unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3321       GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3322       F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3323
3324       // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3325       assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3326       GlobalSLocOffsetMap.insert(
3327           std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3328                            - SLocSpaceSize,&F));
3329
3330       // Initialize the remapping table.
3331       // Invalid stays invalid.
3332       F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3333       // This module. Base was 2 when being compiled.
3334       F.SLocRemap.insertOrReplace(std::make_pair(2U,
3335                                   static_cast<int>(F.SLocEntryBaseOffset - 2)));
3336
3337       TotalNumSLocEntries += F.LocalNumSLocEntries;
3338       break;
3339     }
3340
3341     case MODULE_OFFSET_MAP:
3342       F.ModuleOffsetMap = Blob;
3343       break;
3344
3345     case SOURCE_MANAGER_LINE_TABLE:
3346       if (ParseLineTable(F, Record))
3347         return Failure;
3348       break;
3349
3350     case SOURCE_LOCATION_PRELOADS: {
3351       // Need to transform from the local view (1-based IDs) to the global view,
3352       // which is based off F.SLocEntryBaseID.
3353       if (!F.PreloadSLocEntries.empty()) {
3354         Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3355         return Failure;
3356       }
3357
3358       F.PreloadSLocEntries.swap(Record);
3359       break;
3360     }
3361
3362     case EXT_VECTOR_DECLS:
3363       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3364         ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3365       break;
3366
3367     case VTABLE_USES:
3368       if (Record.size() % 3 != 0) {
3369         Error("Invalid VTABLE_USES record");
3370         return Failure;
3371       }
3372
3373       // Later tables overwrite earlier ones.
3374       // FIXME: Modules will have some trouble with this. This is clearly not
3375       // the right way to do this.
3376       VTableUses.clear();
3377
3378       for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3379         VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3380         VTableUses.push_back(
3381           ReadSourceLocation(F, Record, Idx).getRawEncoding());
3382         VTableUses.push_back(Record[Idx++]);
3383       }
3384       break;
3385
3386     case PENDING_IMPLICIT_INSTANTIATIONS:
3387       if (PendingInstantiations.size() % 2 != 0) {
3388         Error("Invalid existing PendingInstantiations");
3389         return Failure;
3390       }
3391
3392       if (Record.size() % 2 != 0) {
3393         Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3394         return Failure;
3395       }
3396
3397       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3398         PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3399         PendingInstantiations.push_back(
3400           ReadSourceLocation(F, Record, I).getRawEncoding());
3401       }
3402       break;
3403
3404     case SEMA_DECL_REFS:
3405       if (Record.size() != 3) {
3406         Error("Invalid SEMA_DECL_REFS block");
3407         return Failure;
3408       }
3409       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3410         SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3411       break;
3412
3413     case PPD_ENTITIES_OFFSETS: {
3414       F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3415       assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3416       F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3417
3418       unsigned LocalBasePreprocessedEntityID = Record[0];
3419
3420       unsigned StartingID;
3421       if (!PP.getPreprocessingRecord())
3422         PP.createPreprocessingRecord();
3423       if (!PP.getPreprocessingRecord()->getExternalSource())
3424         PP.getPreprocessingRecord()->SetExternalSource(*this);
3425       StartingID
3426         = PP.getPreprocessingRecord()
3427             ->allocateLoadedEntities(F.NumPreprocessedEntities);
3428       F.BasePreprocessedEntityID = StartingID;
3429
3430       if (F.NumPreprocessedEntities > 0) {
3431         // Introduce the global -> local mapping for preprocessed entities in
3432         // this module.
3433         GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3434
3435         // Introduce the local -> global mapping for preprocessed entities in
3436         // this module.
3437         F.PreprocessedEntityRemap.insertOrReplace(
3438           std::make_pair(LocalBasePreprocessedEntityID,
3439             F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3440       }
3441
3442       break;
3443     }
3444
3445     case PPD_SKIPPED_RANGES: {
3446       F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3447       assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3448       F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3449
3450       if (!PP.getPreprocessingRecord())
3451         PP.createPreprocessingRecord();
3452       if (!PP.getPreprocessingRecord()->getExternalSource())
3453         PP.getPreprocessingRecord()->SetExternalSource(*this);
3454       F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3455           ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3456
3457       if (F.NumPreprocessedSkippedRanges > 0)
3458         GlobalSkippedRangeMap.insert(
3459             std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3460       break;
3461     }
3462
3463     case DECL_UPDATE_OFFSETS:
3464       if (Record.size() % 2 != 0) {
3465         Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3466         return Failure;
3467       }
3468       for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3469         GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3470         DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3471
3472         // If we've already loaded the decl, perform the updates when we finish
3473         // loading this block.
3474         if (Decl *D = GetExistingDecl(ID))
3475           PendingUpdateRecords.push_back(
3476               PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3477       }
3478       break;
3479
3480     case OBJC_CATEGORIES_MAP:
3481       if (F.LocalNumObjCCategoriesInMap != 0) {
3482         Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3483         return Failure;
3484       }
3485
3486       F.LocalNumObjCCategoriesInMap = Record[0];
3487       F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3488       break;
3489
3490     case OBJC_CATEGORIES:
3491       F.ObjCCategories.swap(Record);
3492       break;
3493
3494     case CUDA_SPECIAL_DECL_REFS:
3495       // Later tables overwrite earlier ones.
3496       // FIXME: Modules will have trouble with this.
3497       CUDASpecialDeclRefs.clear();
3498       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3499         CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3500       break;
3501
3502     case HEADER_SEARCH_TABLE:
3503       F.HeaderFileInfoTableData = Blob.data();
3504       F.LocalNumHeaderFileInfos = Record[1];
3505       if (Record[0]) {
3506         F.HeaderFileInfoTable
3507           = HeaderFileInfoLookupTable::Create(
3508                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3509                    (const unsigned char *)F.HeaderFileInfoTableData,
3510                    HeaderFileInfoTrait(*this, F,
3511                                        &PP.getHeaderSearchInfo(),
3512                                        Blob.data() + Record[2]));
3513
3514         PP.getHeaderSearchInfo().SetExternalSource(this);
3515         if (!PP.getHeaderSearchInfo().getExternalLookup())
3516           PP.getHeaderSearchInfo().SetExternalLookup(this);
3517       }
3518       break;
3519
3520     case FP_PRAGMA_OPTIONS:
3521       // Later tables overwrite earlier ones.
3522       FPPragmaOptions.swap(Record);
3523       break;
3524
3525     case OPENCL_EXTENSIONS:
3526       for (unsigned I = 0, E = Record.size(); I != E; ) {
3527         auto Name = ReadString(Record, I);
3528         auto &Opt = OpenCLExtensions.OptMap[Name];
3529         Opt.Supported = Record[I++] != 0;
3530         Opt.Enabled = Record[I++] != 0;
3531         Opt.Avail = Record[I++];
3532         Opt.Core = Record[I++];
3533       }
3534       break;
3535
3536     case OPENCL_EXTENSION_TYPES:
3537       for (unsigned I = 0, E = Record.size(); I != E;) {
3538         auto TypeID = static_cast<::TypeID>(Record[I++]);
3539         auto *Type = GetType(TypeID).getTypePtr();
3540         auto NumExt = static_cast<unsigned>(Record[I++]);
3541         for (unsigned II = 0; II != NumExt; ++II) {
3542           auto Ext = ReadString(Record, I);
3543           OpenCLTypeExtMap[Type].insert(Ext);
3544         }
3545       }
3546       break;
3547
3548     case OPENCL_EXTENSION_DECLS:
3549       for (unsigned I = 0, E = Record.size(); I != E;) {
3550         auto DeclID = static_cast<::DeclID>(Record[I++]);
3551         auto *Decl = GetDecl(DeclID);
3552         auto NumExt = static_cast<unsigned>(Record[I++]);
3553         for (unsigned II = 0; II != NumExt; ++II) {
3554           auto Ext = ReadString(Record, I);
3555           OpenCLDeclExtMap[Decl].insert(Ext);
3556         }
3557       }
3558       break;
3559
3560     case TENTATIVE_DEFINITIONS:
3561       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3562         TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3563       break;
3564
3565     case KNOWN_NAMESPACES:
3566       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3567         KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3568       break;
3569
3570     case UNDEFINED_BUT_USED:
3571       if (UndefinedButUsed.size() % 2 != 0) {
3572         Error("Invalid existing UndefinedButUsed");
3573         return Failure;
3574       }
3575
3576       if (Record.size() % 2 != 0) {
3577         Error("invalid undefined-but-used record");
3578         return Failure;
3579       }
3580       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3581         UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3582         UndefinedButUsed.push_back(
3583             ReadSourceLocation(F, Record, I).getRawEncoding());
3584       }
3585       break;
3586
3587     case DELETE_EXPRS_TO_ANALYZE:
3588       for (unsigned I = 0, N = Record.size(); I != N;) {
3589         DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3590         const uint64_t Count = Record[I++];
3591         DelayedDeleteExprs.push_back(Count);
3592         for (uint64_t C = 0; C < Count; ++C) {
3593           DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3594           bool IsArrayForm = Record[I++] == 1;
3595           DelayedDeleteExprs.push_back(IsArrayForm);
3596         }
3597       }
3598       break;
3599
3600     case IMPORTED_MODULES:
3601       if (!F.isModule()) {
3602         // If we aren't loading a module (which has its own exports), make
3603         // all of the imported modules visible.
3604         // FIXME: Deal with macros-only imports.
3605         for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3606           unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3607           SourceLocation Loc = ReadSourceLocation(F, Record, I);
3608           if (GlobalID) {
3609             ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3610             if (DeserializationListener)
3611               DeserializationListener->ModuleImportRead(GlobalID, Loc);
3612           }
3613         }
3614       }
3615       break;
3616
3617     case MACRO_OFFSET: {
3618       if (F.LocalNumMacros != 0) {
3619         Error("duplicate MACRO_OFFSET record in AST file");
3620         return Failure;
3621       }
3622       F.MacroOffsets = (const uint32_t *)Blob.data();
3623       F.LocalNumMacros = Record[0];
3624       unsigned LocalBaseMacroID = Record[1];
3625       F.BaseMacroID = getTotalNumMacros();
3626
3627       if (F.LocalNumMacros > 0) {
3628         // Introduce the global -> local mapping for macros within this module.
3629         GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3630
3631         // Introduce the local -> global mapping for macros within this module.
3632         F.MacroRemap.insertOrReplace(
3633           std::make_pair(LocalBaseMacroID,
3634                          F.BaseMacroID - LocalBaseMacroID));
3635
3636         MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3637       }
3638       break;
3639     }
3640
3641     case LATE_PARSED_TEMPLATE:
3642       LateParsedTemplates.append(Record.begin(), Record.end());
3643       break;
3644
3645     case OPTIMIZE_PRAGMA_OPTIONS:
3646       if (Record.size() != 1) {
3647         Error("invalid pragma optimize record");
3648         return Failure;
3649       }
3650       OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3651       break;
3652
3653     case MSSTRUCT_PRAGMA_OPTIONS:
3654       if (Record.size() != 1) {
3655         Error("invalid pragma ms_struct record");
3656         return Failure;
3657       }
3658       PragmaMSStructState = Record[0];
3659       break;
3660
3661     case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3662       if (Record.size() != 2) {
3663         Error("invalid pragma ms_struct record");
3664         return Failure;
3665       }
3666       PragmaMSPointersToMembersState = Record[0];
3667       PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3668       break;
3669
3670     case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3671       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3672         UnusedLocalTypedefNameCandidates.push_back(
3673             getGlobalDeclID(F, Record[I]));
3674       break;
3675
3676     case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3677       if (Record.size() != 1) {
3678         Error("invalid cuda pragma options record");
3679         return Failure;
3680       }
3681       ForceCUDAHostDeviceDepth = Record[0];
3682       break;
3683
3684     case PACK_PRAGMA_OPTIONS: {
3685       if (Record.size() < 3) {
3686         Error("invalid pragma pack record");
3687         return Failure;
3688       }
3689       PragmaPackCurrentValue = Record[0];
3690       PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3691       unsigned NumStackEntries = Record[2];
3692       unsigned Idx = 3;
3693       // Reset the stack when importing a new module.
3694       PragmaPackStack.clear();
3695       for (unsigned I = 0; I < NumStackEntries; ++I) {
3696         PragmaPackStackEntry Entry;
3697         Entry.Value = Record[Idx++];
3698         Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3699         Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3700         PragmaPackStrings.push_back(ReadString(Record, Idx));
3701         Entry.SlotLabel = PragmaPackStrings.back();
3702         PragmaPackStack.push_back(Entry);
3703       }
3704       break;
3705     }
3706     }
3707   }
3708 }
3709
3710 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3711   assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3712
3713   // Additional remapping information.
3714   const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3715   const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3716   F.ModuleOffsetMap = StringRef();
3717
3718   // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3719   if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3720     F.SLocRemap.insert(std::make_pair(0U, 0));
3721     F.SLocRemap.insert(std::make_pair(2U, 1));
3722   }
3723
3724   // Continuous range maps we may be updating in our module.
3725   using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3726   RemapBuilder SLocRemap(F.SLocRemap);
3727   RemapBuilder IdentifierRemap(F.IdentifierRemap);
3728   RemapBuilder MacroRemap(F.MacroRemap);
3729   RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3730   RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3731   RemapBuilder SelectorRemap(F.SelectorRemap);
3732   RemapBuilder DeclRemap(F.DeclRemap);
3733   RemapBuilder TypeRemap(F.TypeRemap);
3734
3735   while (Data < DataEnd) {
3736     // FIXME: Looking up dependency modules by filename is horrible. Let's
3737     // start fixing this with prebuilt and explicit modules and see how it
3738     // goes...
3739     using namespace llvm::support;
3740     ModuleKind Kind = static_cast<ModuleKind>(
3741       endian::readNext<uint8_t, little, unaligned>(Data));
3742     uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3743     StringRef Name = StringRef((const char*)Data, Len);
3744     Data += Len;
3745     ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3746                       ? ModuleMgr.lookupByModuleName(Name)
3747                       : ModuleMgr.lookupByFileName(Name));
3748     if (!OM) {
3749       std::string Msg =
3750           "SourceLocation remap refers to unknown module, cannot find ";
3751       Msg.append(Name);
3752       Error(Msg);
3753       return;
3754     }
3755
3756     uint32_t SLocOffset =
3757         endian::readNext<uint32_t, little, unaligned>(Data);
3758     uint32_t IdentifierIDOffset =
3759         endian::readNext<uint32_t, little, unaligned>(Data);
3760     uint32_t MacroIDOffset =
3761         endian::readNext<uint32_t, little, unaligned>(Data);
3762     uint32_t PreprocessedEntityIDOffset =
3763         endian::readNext<uint32_t, little, unaligned>(Data);
3764     uint32_t SubmoduleIDOffset =
3765         endian::readNext<uint32_t, little, unaligned>(Data);
3766     uint32_t SelectorIDOffset =
3767         endian::readNext<uint32_t, little, unaligned>(Data);
3768     uint32_t DeclIDOffset =
3769         endian::readNext<uint32_t, little, unaligned>(Data);
3770     uint32_t TypeIndexOffset =
3771         endian::readNext<uint32_t, little, unaligned>(Data);
3772
3773     uint32_t None = std::numeric_limits<uint32_t>::max();
3774
3775     auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3776                          RemapBuilder &Remap) {
3777       if (Offset != None)
3778         Remap.insert(std::make_pair(Offset,
3779                                     static_cast<int>(BaseOffset - Offset)));
3780     };
3781     mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3782     mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3783     mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3784     mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3785               PreprocessedEntityRemap);
3786     mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3787     mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3788     mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3789     mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3790
3791     // Global -> local mappings.
3792     F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3793   }
3794 }
3795
3796 ASTReader::ASTReadResult
3797 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3798                                   const ModuleFile *ImportedBy,
3799                                   unsigned ClientLoadCapabilities) {
3800   unsigned Idx = 0;
3801   F.ModuleMapPath = ReadPath(F, Record, Idx);
3802
3803   // Try to resolve ModuleName in the current header search context and
3804   // verify that it is found in the same module map file as we saved. If the
3805   // top-level AST file is a main file, skip this check because there is no
3806   // usable header search context.
3807   assert(!F.ModuleName.empty() &&
3808          "MODULE_NAME should come before MODULE_MAP_FILE");
3809   if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3810     // An implicitly-loaded module file should have its module listed in some
3811     // module map file that we've already loaded.
3812     Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3813     auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3814     const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3815     // Don't emit module relocation error if we have -fno-validate-pch
3816     if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3817       assert(ImportedBy && "top-level import should be verified");
3818       if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3819         if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3820           // This module was defined by an imported (explicit) module.
3821           Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3822                                                << ASTFE->getName();
3823         } else {
3824           // This module was built with a different module map.
3825           Diag(diag::err_imported_module_not_found)
3826               << F.ModuleName << F.FileName << ImportedBy->FileName
3827               << F.ModuleMapPath;
3828           // In case it was imported by a PCH, there's a chance the user is
3829           // just missing to include the search path to the directory containing
3830           // the modulemap.
3831           if (ImportedBy->Kind == MK_PCH)
3832             Diag(diag::note_imported_by_pch_module_not_found)
3833                 << llvm::sys::path::parent_path(F.ModuleMapPath);
3834         }
3835       }
3836       return OutOfDate;
3837     }
3838
3839     assert(M->Name == F.ModuleName && "found module with different name");
3840
3841     // Check the primary module map file.
3842     const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3843     if (StoredModMap == nullptr || StoredModMap != ModMap) {
3844       assert(ModMap && "found module is missing module map file");
3845       assert(ImportedBy && "top-level import should be verified");
3846       if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3847         Diag(diag::err_imported_module_modmap_changed)
3848           << F.ModuleName << ImportedBy->FileName
3849           << ModMap->getName() << F.ModuleMapPath;
3850       return OutOfDate;
3851     }
3852
3853     llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3854     for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3855       // FIXME: we should use input files rather than storing names.
3856       std::string Filename = ReadPath(F, Record, Idx);
3857       const FileEntry *F =
3858           FileMgr.getFile(Filename, false, false);
3859       if (F == nullptr) {
3860         if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3861           Error("could not find file '" + Filename +"' referenced by AST file");
3862         return OutOfDate;
3863       }
3864       AdditionalStoredMaps.insert(F);
3865     }
3866
3867     // Check any additional module map files (e.g. module.private.modulemap)
3868     // that are not in the pcm.
3869     if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3870       for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3871         // Remove files that match
3872         // Note: SmallPtrSet::erase is really remove
3873         if (!AdditionalStoredMaps.erase(ModMap)) {
3874           if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3875             Diag(diag::err_module_different_modmap)
3876               << F.ModuleName << /*new*/0 << ModMap->getName();
3877           return OutOfDate;
3878         }
3879       }
3880     }
3881
3882     // Check any additional module map files that are in the pcm, but not
3883     // found in header search. Cases that match are already removed.
3884     for (const FileEntry *ModMap : AdditionalStoredMaps) {
3885       if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3886         Diag(diag::err_module_different_modmap)
3887           << F.ModuleName << /*not new*/1 << ModMap->getName();
3888       return OutOfDate;
3889     }
3890   }
3891
3892   if (Listener)
3893     Listener->ReadModuleMapFile(F.ModuleMapPath);
3894   return Success;
3895 }
3896
3897 /// Move the given method to the back of the global list of methods.
3898 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3899   // Find the entry for this selector in the method pool.
3900   Sema::GlobalMethodPool::iterator Known
3901     = S.MethodPool.find(Method->getSelector());
3902   if (Known == S.MethodPool.end())
3903     return;
3904
3905   // Retrieve the appropriate method list.
3906   ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3907                                                     : Known->second.second;
3908   bool Found = false;
3909   for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3910     if (!Found) {
3911       if (List->getMethod() == Method) {
3912         Found = true;
3913       } else {
3914         // Keep searching.
3915         continue;
3916       }
3917     }
3918
3919     if (List->getNext())
3920       List->setMethod(List->getNext()->getMethod());
3921     else
3922       List->setMethod(Method);
3923   }
3924 }
3925
3926 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3927   assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3928   for (Decl *D : Names) {
3929     bool wasHidden = D->isHidden();
3930     D->setVisibleDespiteOwningModule();
3931
3932     if (wasHidden && SemaObj) {
3933       if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3934         moveMethodToBackOfGlobalList(*SemaObj, Method);
3935       }
3936     }
3937   }
3938 }
3939
3940 void ASTReader::makeModuleVisible(Module *Mod,
3941                                   Module::NameVisibilityKind NameVisibility,
3942                                   SourceLocation ImportLoc) {
3943   llvm::SmallPtrSet<Module *, 4> Visited;
3944   SmallVector<Module *, 4> Stack;
3945   Stack.push_back(Mod);
3946   while (!Stack.empty()) {
3947     Mod = Stack.pop_back_val();
3948
3949     if (NameVisibility <= Mod->NameVisibility) {
3950       // This module already has this level of visibility (or greater), so
3951       // there is nothing more to do.
3952       continue;
3953     }
3954
3955     if (!Mod->isAvailable()) {
3956       // Modules that aren't available cannot be made visible.
3957       continue;
3958     }
3959
3960     // Update the module's name visibility.
3961     Mod->NameVisibility = NameVisibility;
3962
3963     // If we've already deserialized any names from this module,
3964     // mark them as visible.
3965     HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3966     if (Hidden != HiddenNamesMap.end()) {
3967       auto HiddenNames = std::move(*Hidden);
3968       HiddenNamesMap.erase(Hidden);
3969       makeNamesVisible(HiddenNames.second, HiddenNames.first);
3970       assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3971              "making names visible added hidden names");
3972     }
3973
3974     // Push any exported modules onto the stack to be marked as visible.
3975     SmallVector<Module *, 16> Exports;
3976     Mod->getExportedModules(Exports);
3977     for (SmallVectorImpl<Module *>::iterator
3978            I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3979       Module *Exported = *I;
3980       if (Visited.insert(Exported).second)
3981         Stack.push_back(Exported);
3982     }
3983   }
3984 }
3985
3986 /// We've merged the definition \p MergedDef into the existing definition
3987 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3988 /// visible.
3989 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
3990                                           NamedDecl *MergedDef) {
3991   if (Def->isHidden()) {
3992     // If MergedDef is visible or becomes visible, make the definition visible.
3993     if (!MergedDef->isHidden())
3994       Def->setVisibleDespiteOwningModule();
3995     else {
3996       getContext().mergeDefinitionIntoModule(
3997           Def, MergedDef->getImportedOwningModule(),
3998           /*NotifyListeners*/ false);
3999       PendingMergedDefinitionsToDeduplicate.insert(Def);
4000     }
4001   }
4002 }
4003
4004 bool ASTReader::loadGlobalIndex() {
4005   if (GlobalIndex)
4006     return false;
4007
4008   if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4009       !PP.getLangOpts().Modules)
4010     return true;
4011
4012   // Try to load the global index.
4013   TriedLoadingGlobalIndex = true;
4014   StringRef ModuleCachePath
4015     = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4016   std::pair<GlobalModuleIndex *, llvm::Error> Result =
4017       GlobalModuleIndex::readIndex(ModuleCachePath);
4018   if (llvm::Error Err = std::move(Result.second)) {
4019     assert(!Result.first);
4020     consumeError(std::move(Err)); // FIXME this drops errors on the floor.
4021     return true;
4022   }
4023
4024   GlobalIndex.reset(Result.first);
4025   ModuleMgr.setGlobalIndex(GlobalIndex.get());
4026   return false;
4027 }
4028
4029 bool ASTReader::isGlobalIndexUnavailable() const {
4030   return PP.getLangOpts().Modules && UseGlobalIndex &&
4031          !hasGlobalIndex() && TriedLoadingGlobalIndex;
4032 }
4033
4034 static void updateModuleTimestamp(ModuleFile &MF) {
4035   // Overwrite the timestamp file contents so that file's mtime changes.
4036   std::string TimestampFilename = MF.getTimestampFilename();
4037   std::error_code EC;
4038   llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
4039   if (EC)
4040     return;
4041   OS << "Timestamp file\n";
4042   OS.close();
4043   OS.clear_error(); // Avoid triggering a fatal error.
4044 }
4045
4046 /// Given a cursor at the start of an AST file, scan ahead and drop the
4047 /// cursor into the start of the given block ID, returning false on success and
4048 /// true on failure.
4049 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
4050   while (true) {
4051     Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
4052     if (!MaybeEntry) {
4053       // FIXME this drops errors on the floor.
4054       consumeError(MaybeEntry.takeError());
4055       return true;
4056     }
4057     llvm::BitstreamEntry Entry = MaybeEntry.get();
4058
4059     switch (Entry.Kind) {
4060     case llvm::BitstreamEntry::Error:
4061     case llvm::BitstreamEntry::EndBlock:
4062       return true;
4063
4064     case llvm::BitstreamEntry::Record:
4065       // Ignore top-level records.
4066       if (Expected<unsigned> Skipped = Cursor.skipRecord(Entry.ID))
4067         break;
4068       else {
4069         // FIXME this drops errors on the floor.
4070         consumeError(Skipped.takeError());
4071         return true;
4072       }
4073
4074     case llvm::BitstreamEntry::SubBlock:
4075       if (Entry.ID == BlockID) {
4076         if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4077           // FIXME this drops the error on the floor.
4078           consumeError(std::move(Err));
4079           return true;
4080         }
4081         // Found it!
4082         return false;
4083       }
4084
4085       if (llvm::Error Err = Cursor.SkipBlock()) {
4086         // FIXME this drops the error on the floor.
4087         consumeError(std::move(Err));
4088         return true;
4089       }
4090     }
4091   }
4092 }
4093
4094 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
4095                                             ModuleKind Type,
4096                                             SourceLocation ImportLoc,
4097                                             unsigned ClientLoadCapabilities,
4098                                             SmallVectorImpl<ImportedSubmodule> *Imported) {
4099   llvm::SaveAndRestore<SourceLocation>
4100     SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
4101
4102   // Defer any pending actions until we get to the end of reading the AST file.
4103   Deserializing AnASTFile(this);
4104
4105   // Bump the generation number.
4106   unsigned PreviousGeneration = 0;
4107   if (ContextObj)
4108     PreviousGeneration = incrementGeneration(*ContextObj);
4109
4110   unsigned NumModules = ModuleMgr.size();
4111   SmallVector<ImportedModule, 4> Loaded;
4112   switch (ASTReadResult ReadResult =
4113               ReadASTCore(FileName, Type, ImportLoc,
4114                           /*ImportedBy=*/nullptr, Loaded, 0, 0,
4115                           ASTFileSignature(), ClientLoadCapabilities)) {
4116   case Failure:
4117   case Missing:
4118   case OutOfDate:
4119   case VersionMismatch:
4120   case ConfigurationMismatch:
4121   case HadErrors: {
4122     llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
4123     for (const ImportedModule &IM : Loaded)
4124       LoadedSet.insert(IM.Mod);
4125
4126     ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
4127                             PP.getLangOpts().Modules
4128                                 ? &PP.getHeaderSearchInfo().getModuleMap()
4129                                 : nullptr);