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