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

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