lib/Serialization/ASTReader.cpp

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