granicus.if.org Git - clang/blob - lib/Serialization/ASTReader.cpp

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