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