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