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

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