contrib/llvm/tools/clang/lib/Serialization/ASTReader.cpp

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