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       llvm::MemoryBuffer *Buffer
1228         = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName());
1229       SourceMgr.overrideFileContents(File, 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     llvm::MemoryBuffer *Buffer
1255       = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name);
1256     SourceMgr.createFileID(Buffer, FileCharacter, ID, BaseOffset + Offset,
1257                            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       ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
2904       ContinuousRangeMap<uint32_t, int, 2>::Builder
2905         IdentifierRemap(F.IdentifierRemap);
2906       ContinuousRangeMap<uint32_t, int, 2>::Builder
2907         MacroRemap(F.MacroRemap);
2908       ContinuousRangeMap<uint32_t, int, 2>::Builder
2909         PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2910       ContinuousRangeMap<uint32_t, int, 2>::Builder
2911         SubmoduleRemap(F.SubmoduleRemap);
2912       ContinuousRangeMap<uint32_t, int, 2>::Builder
2913         SelectorRemap(F.SelectorRemap);
2914       ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap);
2915       ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap);
2916
2917       while(Data < DataEnd) {
2918         using namespace llvm::support;
2919         uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
2920         StringRef Name = StringRef((const char*)Data, Len);
2921         Data += Len;
2922         ModuleFile *OM = ModuleMgr.lookup(Name);
2923         if (!OM) {
2924           Error("SourceLocation remap refers to unknown module");
2925           return Failure;
2926         }
2927
2928         uint32_t SLocOffset =
2929             endian::readNext<uint32_t, little, unaligned>(Data);
2930         uint32_t IdentifierIDOffset =
2931             endian::readNext<uint32_t, little, unaligned>(Data);
2932         uint32_t MacroIDOffset =
2933             endian::readNext<uint32_t, little, unaligned>(Data);
2934         uint32_t PreprocessedEntityIDOffset =
2935             endian::readNext<uint32_t, little, unaligned>(Data);
2936         uint32_t SubmoduleIDOffset =
2937             endian::readNext<uint32_t, little, unaligned>(Data);
2938         uint32_t SelectorIDOffset =
2939             endian::readNext<uint32_t, little, unaligned>(Data);
2940         uint32_t DeclIDOffset =
2941             endian::readNext<uint32_t, little, unaligned>(Data);
2942         uint32_t TypeIndexOffset =
2943             endian::readNext<uint32_t, little, unaligned>(Data);
2944
2945         // Source location offset is mapped to OM->SLocEntryBaseOffset.
2946         SLocRemap.insert(std::make_pair(SLocOffset,
2947           static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
2948         IdentifierRemap.insert(
2949           std::make_pair(IdentifierIDOffset,
2950                          OM->BaseIdentifierID - IdentifierIDOffset));
2951         MacroRemap.insert(std::make_pair(MacroIDOffset,
2952                                          OM->BaseMacroID - MacroIDOffset));
2953         PreprocessedEntityRemap.insert(
2954           std::make_pair(PreprocessedEntityIDOffset,
2955             OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset));
2956         SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset,
2957                                       OM->BaseSubmoduleID - SubmoduleIDOffset));
2958         SelectorRemap.insert(std::make_pair(SelectorIDOffset,
2959                                OM->BaseSelectorID - SelectorIDOffset));
2960         DeclRemap.insert(std::make_pair(DeclIDOffset,
2961                                         OM->BaseDeclID - DeclIDOffset));
2962
2963         TypeRemap.insert(std::make_pair(TypeIndexOffset,
2964                                     OM->BaseTypeIndex - TypeIndexOffset));
2965
2966         // Global -> local mappings.
2967         F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
2968       }
2969       break;
2970     }
2971
2972     case SOURCE_MANAGER_LINE_TABLE:
2973       if (ParseLineTable(F, Record))
2974         return Failure;
2975       break;
2976
2977     case SOURCE_LOCATION_PRELOADS: {
2978       // Need to transform from the local view (1-based IDs) to the global view,
2979       // which is based off F.SLocEntryBaseID.
2980       if (!F.PreloadSLocEntries.empty()) {
2981         Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
2982         return Failure;
2983       }
2984
2985       F.PreloadSLocEntries.swap(Record);
2986       break;
2987     }
2988
2989     case EXT_VECTOR_DECLS:
2990       for (unsigned I = 0, N = Record.size(); I != N; ++I)
2991         ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2992       break;
2993
2994     case VTABLE_USES:
2995       if (Record.size() % 3 != 0) {
2996         Error("Invalid VTABLE_USES record");
2997         return Failure;
2998       }
2999
3000       // Later tables overwrite earlier ones.
3001       // FIXME: Modules will have some trouble with this. This is clearly not
3002       // the right way to do this.
3003       VTableUses.clear();
3004
3005       for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3006         VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3007         VTableUses.push_back(
3008           ReadSourceLocation(F, Record, Idx).getRawEncoding());
3009         VTableUses.push_back(Record[Idx++]);
3010       }
3011       break;
3012
3013     case DYNAMIC_CLASSES:
3014       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3015         DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
3016       break;
3017
3018     case PENDING_IMPLICIT_INSTANTIATIONS:
3019       if (PendingInstantiations.size() % 2 != 0) {
3020         Error("Invalid existing PendingInstantiations");
3021         return Failure;
3022       }
3023
3024       if (Record.size() % 2 != 0) {
3025         Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3026         return Failure;
3027       }
3028
3029       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3030         PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3031         PendingInstantiations.push_back(
3032           ReadSourceLocation(F, Record, I).getRawEncoding());
3033       }
3034       break;
3035
3036     case SEMA_DECL_REFS:
3037       if (Record.size() != 2) {
3038         Error("Invalid SEMA_DECL_REFS block");
3039         return Failure;
3040       }
3041       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3042         SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3043       break;
3044
3045     case PPD_ENTITIES_OFFSETS: {
3046       F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3047       assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3048       F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3049
3050       unsigned LocalBasePreprocessedEntityID = Record[0];
3051
3052       unsigned StartingID;
3053       if (!PP.getPreprocessingRecord())
3054         PP.createPreprocessingRecord();
3055       if (!PP.getPreprocessingRecord()->getExternalSource())
3056         PP.getPreprocessingRecord()->SetExternalSource(*this);
3057
3058       // Increase size by >= 1 so we get a unique base index in the next module.
3059       StartingID
3060         = PP.getPreprocessingRecord()
3061             ->allocateLoadedEntities(std::max(F.NumPreprocessedEntities, 1U));
3062       F.BasePreprocessedEntityID = StartingID;
3063
3064       if (F.NumPreprocessedEntities > 0) {
3065         // Introduce the global -> local mapping for preprocessed entities in
3066         // this module.
3067         GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3068
3069         // Introduce the local -> global mapping for preprocessed entities in
3070         // this module.
3071         F.PreprocessedEntityRemap.insertOrReplace(
3072           std::make_pair(LocalBasePreprocessedEntityID,
3073             F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3074       }
3075
3076       break;
3077     }
3078
3079     case DECL_UPDATE_OFFSETS: {
3080       if (Record.size() % 2 != 0) {
3081         Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3082         return Failure;
3083       }
3084       for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3085         GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3086         DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3087
3088         // If we've already loaded the decl, perform the updates when we finish
3089         // loading this block.
3090         if (Decl *D = GetExistingDecl(ID))
3091           PendingUpdateRecords.push_back(std::make_pair(ID, D));
3092       }
3093       break;
3094     }
3095
3096     case DECL_REPLACEMENTS: {
3097       if (Record.size() % 3 != 0) {
3098         Error("invalid DECL_REPLACEMENTS block in AST file");
3099         return Failure;
3100       }
3101       for (unsigned I = 0, N = Record.size(); I != N; I += 3)
3102         ReplacedDecls[getGlobalDeclID(F, Record[I])]
3103           = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]);
3104       break;
3105     }
3106
3107     case OBJC_CATEGORIES_MAP: {
3108       if (F.LocalNumObjCCategoriesInMap != 0) {
3109         Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3110         return Failure;
3111       }
3112
3113       F.LocalNumObjCCategoriesInMap = Record[0];
3114       F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3115       break;
3116     }
3117
3118     case OBJC_CATEGORIES:
3119       F.ObjCCategories.swap(Record);
3120       break;
3121
3122     case CXX_BASE_SPECIFIER_OFFSETS: {
3123       if (F.LocalNumCXXBaseSpecifiers != 0) {
3124         Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
3125         return Failure;
3126       }
3127
3128       F.LocalNumCXXBaseSpecifiers = Record[0];
3129       F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data();
3130       NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
3131       break;
3132     }
3133
3134     case DIAG_PRAGMA_MAPPINGS:
3135       if (F.PragmaDiagMappings.empty())
3136         F.PragmaDiagMappings.swap(Record);
3137       else
3138         F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
3139                                     Record.begin(), Record.end());
3140       break;
3141
3142     case CUDA_SPECIAL_DECL_REFS:
3143       // Later tables overwrite earlier ones.
3144       // FIXME: Modules will have trouble with this.
3145       CUDASpecialDeclRefs.clear();
3146       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3147         CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3148       break;
3149
3150     case HEADER_SEARCH_TABLE: {
3151       F.HeaderFileInfoTableData = Blob.data();
3152       F.LocalNumHeaderFileInfos = Record[1];
3153       if (Record[0]) {
3154         F.HeaderFileInfoTable
3155           = HeaderFileInfoLookupTable::Create(
3156                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3157                    (const unsigned char *)F.HeaderFileInfoTableData,
3158                    HeaderFileInfoTrait(*this, F,
3159                                        &PP.getHeaderSearchInfo(),
3160                                        Blob.data() + Record[2]));
3161
3162         PP.getHeaderSearchInfo().SetExternalSource(this);
3163         if (!PP.getHeaderSearchInfo().getExternalLookup())
3164           PP.getHeaderSearchInfo().SetExternalLookup(this);
3165       }
3166       break;
3167     }
3168
3169     case FP_PRAGMA_OPTIONS:
3170       // Later tables overwrite earlier ones.
3171       FPPragmaOptions.swap(Record);
3172       break;
3173
3174     case OPENCL_EXTENSIONS:
3175       // Later tables overwrite earlier ones.
3176       OpenCLExtensions.swap(Record);
3177       break;
3178
3179     case TENTATIVE_DEFINITIONS:
3180       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3181         TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3182       break;
3183
3184     case KNOWN_NAMESPACES:
3185       for (unsigned I = 0, N = Record.size(); I != N; ++I)
3186         KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3187       break;
3188
3189     case UNDEFINED_BUT_USED:
3190       if (UndefinedButUsed.size() % 2 != 0) {
3191         Error("Invalid existing UndefinedButUsed");
3192         return Failure;
3193       }
3194
3195       if (Record.size() % 2 != 0) {
3196         Error("invalid undefined-but-used record");
3197         return Failure;
3198       }
3199       for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3200         UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3201         UndefinedButUsed.push_back(
3202             ReadSourceLocation(F, Record, I).getRawEncoding());
3203       }
3204       break;
3205
3206     case IMPORTED_MODULES: {
3207       if (F.Kind != MK_Module) {
3208         // If we aren't loading a module (which has its own exports), make
3209         // all of the imported modules visible.
3210         // FIXME: Deal with macros-only imports.
3211         for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3212           unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3213           SourceLocation Loc = ReadSourceLocation(F, Record, I);
3214           if (GlobalID)
3215             ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3216         }
3217       }
3218       break;
3219     }
3220
3221     case LOCAL_REDECLARATIONS: {
3222       F.RedeclarationChains.swap(Record);
3223       break;
3224     }
3225
3226     case LOCAL_REDECLARATIONS_MAP: {
3227       if (F.LocalNumRedeclarationsInMap != 0) {
3228         Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file");
3229         return Failure;
3230       }
3231
3232       F.LocalNumRedeclarationsInMap = Record[0];
3233       F.RedeclarationsMap = (const LocalRedeclarationsInfo *)Blob.data();
3234       break;
3235     }
3236
3237     case MERGED_DECLARATIONS: {
3238       for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) {
3239         GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]);
3240         SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID];
3241         for (unsigned N = Record[Idx++]; N > 0; --N)
3242           Decls.push_back(getGlobalDeclID(F, Record[Idx++]));
3243       }
3244       break;
3245     }
3246
3247     case MACRO_OFFSET: {
3248       if (F.LocalNumMacros != 0) {
3249         Error("duplicate MACRO_OFFSET record in AST file");
3250         return Failure;
3251       }
3252       F.MacroOffsets = (const uint32_t *)Blob.data();
3253       F.LocalNumMacros = Record[0];
3254       unsigned LocalBaseMacroID = Record[1];
3255       F.BaseMacroID = getTotalNumMacros();
3256
3257       if (F.LocalNumMacros > 0) {
3258         // Introduce the global -> local mapping for macros within this module.
3259         GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3260
3261         // Introduce the local -> global mapping for macros within this module.
3262         F.MacroRemap.insertOrReplace(
3263           std::make_pair(LocalBaseMacroID,
3264                          F.BaseMacroID - LocalBaseMacroID));
3265       }
3266       // Increase size by >= 1 so we get a unique base index in the next module.
3267       MacrosLoaded.resize(MacrosLoaded.size() + std::max(F.LocalNumMacros, 1U));
3268       break;
3269     }
3270
3271     case MACRO_TABLE: {
3272       // FIXME: Not used yet.
3273       break;
3274     }
3275
3276     case LATE_PARSED_TEMPLATE: {
3277       LateParsedTemplates.append(Record.begin(), Record.end());
3278       break;
3279     }
3280
3281     case OPTIMIZE_PRAGMA_OPTIONS:
3282       if (Record.size() != 1) {
3283         Error("invalid pragma optimize record");
3284         return Failure;
3285       }
3286       OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
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::string ErrorInfo;
3525   llvm::raw_fd_ostream OS(TimestampFilename.c_str(), ErrorInfo,
3526                           llvm::sys::fs::F_Text);
3527   if (!ErrorInfo.empty())
3528     return;
3529   OS << "Timestamp file\n";
3530 }
3531
3532 ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
3533                                             ModuleKind Type,
3534                                             SourceLocation ImportLoc,
3535                                             unsigned ClientLoadCapabilities) {
3536   llvm::SaveAndRestore<SourceLocation>
3537     SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3538
3539   // Defer any pending actions until we get to the end of reading the AST file.
3540   Deserializing AnASTFile(this);
3541
3542   // Bump the generation number.
3543   unsigned PreviousGeneration = incrementGeneration(Context);
3544
3545   unsigned NumModules = ModuleMgr.size();
3546   SmallVector<ImportedModule, 4> Loaded;
3547   switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
3548                                                 /*ImportedBy=*/nullptr, Loaded,
3549                                                 0, 0,
3550                                                 ClientLoadCapabilities)) {
3551   case Failure:
3552   case Missing:
3553   case OutOfDate:
3554   case VersionMismatch:
3555   case ConfigurationMismatch:
3556   case HadErrors: {
3557     llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3558     for (const ImportedModule &IM : Loaded)
3559       LoadedSet.insert(IM.Mod);
3560
3561     ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
3562                             LoadedSet,
3563                             Context.getLangOpts().Modules
3564                               ? &PP.getHeaderSearchInfo().getModuleMap()
3565                               : nullptr);
3566
3567     // If we find that any modules are unusable, the global index is going
3568     // to be out-of-date. Just remove it.
3569     GlobalIndex.reset();
3570     ModuleMgr.setGlobalIndex(nullptr);
3571     return ReadResult;
3572   }
3573   case Success:
3574     break;
3575   }
3576
3577   // Here comes stuff that we only do once the entire chain is loaded.
3578
3579   // Load the AST blocks of all of the modules that we loaded.
3580   for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3581                                               MEnd = Loaded.end();
3582        M != MEnd; ++M) {
3583     ModuleFile &F = *M->Mod;
3584
3585     // Read the AST block.
3586     if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3587       return Result;
3588
3589     // Once read, set the ModuleFile bit base offset and update the size in
3590     // bits of all files we've seen.
3591     F.GlobalBitOffset = TotalModulesSizeInBits;
3592     TotalModulesSizeInBits += F.SizeInBits;
3593     GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3594
3595     // Preload SLocEntries.
3596     for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3597       int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3598       // Load it through the SourceManager and don't call ReadSLocEntry()
3599       // directly because the entry may have already been loaded in which case
3600       // calling ReadSLocEntry() directly would trigger an assertion in
3601       // SourceManager.
3602       SourceMgr.getLoadedSLocEntryByID(Index);
3603     }
3604   }
3605
3606   // Setup the import locations and notify the module manager that we've
3607   // committed to these module files.
3608   for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3609                                               MEnd = Loaded.end();
3610        M != MEnd; ++M) {
3611     ModuleFile &F = *M->Mod;
3612
3613     ModuleMgr.moduleFileAccepted(&F);
3614
3615     // Set the import location.
3616     F.DirectImportLoc = ImportLoc;
3617     if (!M->ImportedBy)
3618       F.ImportLoc = M->ImportLoc;
3619     else
3620       F.ImportLoc = ReadSourceLocation(*M->ImportedBy,
3621                                        M->ImportLoc.getRawEncoding());
3622   }
3623
3624   // Mark all of the identifiers in the identifier table as being out of date,
3625   // so that various accessors know to check the loaded modules when the
3626   // identifier is used.
3627   for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3628                               IdEnd = PP.getIdentifierTable().end();
3629        Id != IdEnd; ++Id)
3630     Id->second->setOutOfDate(true);
3631
3632   // Resolve any unresolved module exports.
3633   for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3634     UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3635     SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3636     Module *ResolvedMod = getSubmodule(GlobalID);
3637
3638     switch (Unresolved.Kind) {
3639     case UnresolvedModuleRef::Conflict:
3640       if (ResolvedMod) {
3641         Module::Conflict Conflict;
3642         Conflict.Other = ResolvedMod;
3643         Conflict.Message = Unresolved.String.str();
3644         Unresolved.Mod->Conflicts.push_back(Conflict);
3645       }
3646       continue;
3647
3648     case UnresolvedModuleRef::Import:
3649       if (ResolvedMod)
3650         Unresolved.Mod->Imports.push_back(ResolvedMod);
3651       continue;
3652
3653     case UnresolvedModuleRef::Export:
3654       if (ResolvedMod || Unresolved.IsWildcard)
3655         Unresolved.Mod->Exports.push_back(
3656           Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3657       continue;
3658     }
3659   }
3660   UnresolvedModuleRefs.clear();
3661
3662   // FIXME: How do we load the 'use'd modules? They may not be submodules.
3663   // Might be unnecessary as use declarations are only used to build the
3664   // module itself.
3665
3666   InitializeContext();
3667
3668   if (SemaObj)
3669     UpdateSema();
3670
3671   if (DeserializationListener)
3672     DeserializationListener->ReaderInitialized(this);
3673
3674   ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3675   if (!PrimaryModule.OriginalSourceFileID.isInvalid()) {
3676     PrimaryModule.OriginalSourceFileID
3677       = FileID::get(PrimaryModule.SLocEntryBaseID
3678                     + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
3679
3680     // If this AST file is a precompiled preamble, then set the
3681     // preamble file ID of the source manager to the file source file
3682     // from which the preamble was built.
3683     if (Type == MK_Preamble) {
3684       SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3685     } else if (Type == MK_MainFile) {
3686       SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3687     }
3688   }
3689
3690   // For any Objective-C class definitions we have already loaded, make sure
3691   // that we load any additional categories.
3692   for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3693     loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3694                        ObjCClassesLoaded[I],
3695                        PreviousGeneration);
3696   }
3697
3698   if (PP.getHeaderSearchInfo()
3699           .getHeaderSearchOpts()
3700           .ModulesValidateOncePerBuildSession) {
3701     // Now we are certain that the module and all modules it depends on are
3702     // up to date.  Create or update timestamp files for modules that are
3703     // located in the module cache (not for PCH files that could be anywhere
3704     // in the filesystem).
3705     for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3706       ImportedModule &M = Loaded[I];
3707       if (M.Mod->Kind == MK_Module) {
3708         updateModuleTimestamp(*M.Mod);
3709       }
3710     }
3711   }
3712
3713   return Success;
3714 }
3715
3716 ASTReader::ASTReadResult
3717 ASTReader::ReadASTCore(StringRef FileName,
3718                        ModuleKind Type,
3719                        SourceLocation ImportLoc,
3720                        ModuleFile *ImportedBy,
3721                        SmallVectorImpl<ImportedModule> &Loaded,
3722                        off_t ExpectedSize, time_t ExpectedModTime,
3723                        unsigned ClientLoadCapabilities) {
3724   ModuleFile *M;
3725   std::string ErrorStr;
3726   ModuleManager::AddModuleResult AddResult
3727     = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
3728                           getGeneration(), ExpectedSize, ExpectedModTime,
3729                           M, ErrorStr);
3730
3731   switch (AddResult) {
3732   case ModuleManager::AlreadyLoaded:
3733     return Success;
3734
3735   case ModuleManager::NewlyLoaded:
3736     // Load module file below.
3737     break;
3738
3739   case ModuleManager::Missing:
3740     // The module file was missing; if the client handle handle, that, return
3741     // it.
3742     if (ClientLoadCapabilities & ARR_Missing)
3743       return Missing;
3744
3745     // Otherwise, return an error.
3746     {
3747       std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
3748                       + ErrorStr;
3749       Error(Msg);
3750     }
3751     return Failure;
3752
3753   case ModuleManager::OutOfDate:
3754     // We couldn't load the module file because it is out-of-date. If the
3755     // client can handle out-of-date, return it.
3756     if (ClientLoadCapabilities & ARR_OutOfDate)
3757       return OutOfDate;
3758
3759     // Otherwise, return an error.
3760     {
3761       std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
3762                       + ErrorStr;
3763       Error(Msg);
3764     }
3765     return Failure;
3766   }
3767
3768   assert(M && "Missing module file");
3769
3770   // FIXME: This seems rather a hack. Should CurrentDir be part of the
3771   // module?
3772   if (FileName != "-") {
3773     CurrentDir = llvm::sys::path::parent_path(FileName);
3774     if (CurrentDir.empty()) CurrentDir = ".";
3775   }
3776
3777   ModuleFile &F = *M;
3778   BitstreamCursor &Stream = F.Stream;
3779   Stream.init(F.StreamFile);
3780   F.SizeInBits = F.Buffer->getBufferSize() * 8;
3781
3782   // Sniff for the signature.
3783   if (Stream.Read(8) != 'C' ||
3784       Stream.Read(8) != 'P' ||
3785       Stream.Read(8) != 'C' ||
3786       Stream.Read(8) != 'H') {
3787     Diag(diag::err_not_a_pch_file) << FileName;
3788     return Failure;
3789   }
3790
3791   // This is used for compatibility with older PCH formats.
3792   bool HaveReadControlBlock = false;
3793
3794   while (1) {
3795     llvm::BitstreamEntry Entry = Stream.advance();
3796
3797     switch (Entry.Kind) {
3798     case llvm::BitstreamEntry::Error:
3799     case llvm::BitstreamEntry::EndBlock:
3800     case llvm::BitstreamEntry::Record:
3801       Error("invalid record at top-level of AST file");
3802       return Failure;
3803
3804     case llvm::BitstreamEntry::SubBlock:
3805       break;
3806     }
3807
3808     // We only know the control subblock ID.
3809     switch (Entry.ID) {
3810     case llvm::bitc::BLOCKINFO_BLOCK_ID:
3811       if (Stream.ReadBlockInfoBlock()) {
3812         Error("malformed BlockInfoBlock in AST file");
3813         return Failure;
3814       }
3815       break;
3816     case CONTROL_BLOCK_ID:
3817       HaveReadControlBlock = true;
3818       switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
3819       case Success:
3820         break;
3821
3822       case Failure: return Failure;
3823       case Missing: return Missing;
3824       case OutOfDate: return OutOfDate;
3825       case VersionMismatch: return VersionMismatch;
3826       case ConfigurationMismatch: return ConfigurationMismatch;
3827       case HadErrors: return HadErrors;
3828       }
3829       break;
3830     case AST_BLOCK_ID:
3831       if (!HaveReadControlBlock) {
3832         if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3833           Diag(diag::err_pch_version_too_old);
3834         return VersionMismatch;
3835       }
3836
3837       // Record that we've loaded this module.
3838       Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
3839       return Success;
3840
3841     default:
3842       if (Stream.SkipBlock()) {
3843         Error("malformed block record in AST file");
3844         return Failure;
3845       }
3846       break;
3847     }
3848   }
3849
3850   return Success;
3851 }
3852
3853 void ASTReader::InitializeContext() {
3854   // If there's a listener, notify them that we "read" the translation unit.
3855   if (DeserializationListener)
3856     DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
3857                                       Context.getTranslationUnitDecl());
3858
3859   // FIXME: Find a better way to deal with collisions between these
3860   // built-in types. Right now, we just ignore the problem.
3861
3862   // Load the special types.
3863   if (SpecialTypes.size() >= NumSpecialTypeIDs) {
3864     if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3865       if (!Context.CFConstantStringTypeDecl)
3866         Context.setCFConstantStringType(GetType(String));
3867     }
3868
3869     if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3870       QualType FileType = GetType(File);
3871       if (FileType.isNull()) {
3872         Error("FILE type is NULL");
3873         return;
3874       }
3875
3876       if (!Context.FILEDecl) {
3877         if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3878           Context.setFILEDecl(Typedef->getDecl());
3879         else {
3880           const TagType *Tag = FileType->getAs<TagType>();
3881           if (!Tag) {
3882             Error("Invalid FILE type in AST file");
3883             return;
3884           }
3885           Context.setFILEDecl(Tag->getDecl());
3886         }
3887       }
3888     }
3889
3890     if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
3891       QualType Jmp_bufType = GetType(Jmp_buf);
3892       if (Jmp_bufType.isNull()) {
3893         Error("jmp_buf type is NULL");
3894         return;
3895       }
3896
3897       if (!Context.jmp_bufDecl) {
3898         if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3899           Context.setjmp_bufDecl(Typedef->getDecl());
3900         else {
3901           const TagType *Tag = Jmp_bufType->getAs<TagType>();
3902           if (!Tag) {
3903             Error("Invalid jmp_buf type in AST file");
3904             return;
3905           }
3906           Context.setjmp_bufDecl(Tag->getDecl());
3907         }
3908       }
3909     }
3910
3911     if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
3912       QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3913       if (Sigjmp_bufType.isNull()) {
3914         Error("sigjmp_buf type is NULL");
3915         return;
3916       }
3917
3918       if (!Context.sigjmp_bufDecl) {
3919         if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3920           Context.setsigjmp_bufDecl(Typedef->getDecl());
3921         else {
3922           const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
3923           assert(Tag && "Invalid sigjmp_buf type in AST file");
3924           Context.setsigjmp_bufDecl(Tag->getDecl());
3925         }
3926       }
3927     }
3928
3929     if (unsigned ObjCIdRedef
3930           = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
3931       if (Context.ObjCIdRedefinitionType.isNull())
3932         Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
3933     }
3934
3935     if (unsigned ObjCClassRedef
3936           = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
3937       if (Context.ObjCClassRedefinitionType.isNull())
3938         Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
3939     }
3940
3941     if (unsigned ObjCSelRedef
3942           = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
3943       if (Context.ObjCSelRedefinitionType.isNull())
3944         Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
3945     }
3946
3947     if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
3948       QualType Ucontext_tType = GetType(Ucontext_t);
3949       if (Ucontext_tType.isNull()) {
3950         Error("ucontext_t type is NULL");
3951         return;
3952       }
3953
3954       if (!Context.ucontext_tDecl) {
3955         if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
3956           Context.setucontext_tDecl(Typedef->getDecl());
3957         else {
3958           const TagType *Tag = Ucontext_tType->getAs<TagType>();
3959           assert(Tag && "Invalid ucontext_t type in AST file");
3960           Context.setucontext_tDecl(Tag->getDecl());
3961         }
3962       }
3963     }
3964   }
3965
3966   ReadPragmaDiagnosticMappings(Context.getDiagnostics());
3967
3968   // If there were any CUDA special declarations, deserialize them.
3969   if (!CUDASpecialDeclRefs.empty()) {
3970     assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
3971     Context.setcudaConfigureCallDecl(
3972                            cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
3973   }
3974
3975   // Re-export any modules that were imported by a non-module AST file.
3976   // FIXME: This does not make macro-only imports visible again. It also doesn't
3977   // make #includes mapped to module imports visible.
3978   for (auto &Import : ImportedModules) {
3979     if (Module *Imported = getSubmodule(Import.ID))
3980       makeModuleVisible(Imported, Module::AllVisible,
3981                         /*ImportLoc=*/Import.ImportLoc,
3982                         /*Complain=*/false);
3983   }
3984   ImportedModules.clear();
3985 }
3986
3987 void ASTReader::finalizeForWriting() {
3988   while (!HiddenNamesMap.empty()) {
3989     auto HiddenNames = std::move(*HiddenNamesMap.begin());
3990     HiddenNamesMap.erase(HiddenNamesMap.begin());
3991     makeNamesVisible(HiddenNames.second, HiddenNames.first,
3992                      /*FromFinalization*/true);
3993   }
3994 }
3995
3996 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3997 /// cursor into the start of the given block ID, returning false on success and
3998 /// true on failure.
3999 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
4000   while (1) {
4001     llvm::BitstreamEntry Entry = Cursor.advance();
4002     switch (Entry.Kind) {
4003     case llvm::BitstreamEntry::Error:
4004     case llvm::BitstreamEntry::EndBlock:
4005       return true;
4006
4007     case llvm::BitstreamEntry::Record:
4008       // Ignore top-level records.
4009       Cursor.skipRecord(Entry.ID);
4010       break;
4011
4012     case llvm::BitstreamEntry::SubBlock:
4013       if (Entry.ID == BlockID) {
4014         if (Cursor.EnterSubBlock(BlockID))
4015           return true;
4016         // Found it!
4017         return false;
4018       }
4019
4020       if (Cursor.SkipBlock())
4021         return true;
4022     }
4023   }
4024 }
4025
4026 /// \brief Retrieve the name of the original source file name
4027 /// directly from the AST file, without actually loading the AST
4028 /// file.
4029 std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
4030                                              FileManager &FileMgr,
4031                                              DiagnosticsEngine &Diags) {
4032   // Open the AST file.
4033   std::string ErrStr;
4034   std::unique_ptr<llvm::MemoryBuffer> Buffer;
4035   Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
4036   if (!Buffer) {
4037     Diags.Report(diag::err_fe_unable_to_read_pch_file) << ASTFileName << ErrStr;
4038     return std::string();
4039   }
4040
4041   // Initialize the stream
4042   llvm::BitstreamReader StreamFile;
4043   BitstreamCursor Stream;
4044   StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
4045                   (const unsigned char *)Buffer->getBufferEnd());
4046   Stream.init(StreamFile);
4047
4048   // Sniff for the signature.
4049   if (Stream.Read(8) != 'C' ||
4050       Stream.Read(8) != 'P' ||
4051       Stream.Read(8) != 'C' ||
4052       Stream.Read(8) != 'H') {
4053     Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4054     return std::string();
4055   }
4056
4057   // Scan for the CONTROL_BLOCK_ID block.
4058   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4059     Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4060     return std::string();
4061   }
4062
4063   // Scan for ORIGINAL_FILE inside the control block.
4064   RecordData Record;
4065   while (1) {
4066     llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4067     if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4068       return std::string();
4069
4070     if (Entry.Kind != llvm::BitstreamEntry::Record) {
4071       Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4072       return std::string();
4073     }
4074
4075     Record.clear();
4076     StringRef Blob;
4077     if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4078       return Blob.str();
4079   }
4080 }
4081
4082 namespace {
4083   class SimplePCHValidator : public ASTReaderListener {
4084     const LangOptions &ExistingLangOpts;
4085     const TargetOptions &ExistingTargetOpts;
4086     const PreprocessorOptions &ExistingPPOpts;
4087     FileManager &FileMgr;
4088
4089   public:
4090     SimplePCHValidator(const LangOptions &ExistingLangOpts,
4091                        const TargetOptions &ExistingTargetOpts,
4092                        const PreprocessorOptions &ExistingPPOpts,
4093                        FileManager &FileMgr)
4094       : ExistingLangOpts(ExistingLangOpts),
4095         ExistingTargetOpts(ExistingTargetOpts),
4096         ExistingPPOpts(ExistingPPOpts),
4097         FileMgr(FileMgr)
4098     {
4099     }
4100
4101     bool ReadLanguageOptions(const LangOptions &LangOpts,
4102                              bool Complain) override {
4103       return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr);
4104     }
4105     bool ReadTargetOptions(const TargetOptions &TargetOpts,
4106                            bool Complain) override {
4107       return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr);
4108     }
4109     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4110                                  bool Complain,
4111                                  std::string &SuggestedPredefines) override {
4112       return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4113                                       SuggestedPredefines, ExistingLangOpts);
4114     }
4115   };
4116 }
4117
4118 bool ASTReader::readASTFileControlBlock(StringRef Filename,
4119                                         FileManager &FileMgr,
4120                                         ASTReaderListener &Listener) {
4121   // Open the AST file.
4122   std::string ErrStr;
4123   std::unique_ptr<llvm::MemoryBuffer> Buffer;
4124   Buffer.reset(FileMgr.getBufferForFile(Filename, &ErrStr));
4125   if (!Buffer) {
4126     return true;
4127   }
4128
4129   // Initialize the stream
4130   llvm::BitstreamReader StreamFile;
4131   BitstreamCursor Stream;
4132   StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
4133                   (const unsigned char *)Buffer->getBufferEnd());
4134   Stream.init(StreamFile);
4135
4136   // Sniff for the signature.
4137   if (Stream.Read(8) != 'C' ||
4138       Stream.Read(8) != 'P' ||
4139       Stream.Read(8) != 'C' ||
4140       Stream.Read(8) != 'H') {
4141     return true;
4142   }
4143
4144   // Scan for the CONTROL_BLOCK_ID block.
4145   if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4146     return true;
4147
4148   bool NeedsInputFiles = Listener.needsInputFileVisitation();
4149   bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4150   BitstreamCursor InputFilesCursor;
4151   if (NeedsInputFiles) {
4152     InputFilesCursor = Stream;
4153     if (SkipCursorToBlock(InputFilesCursor, INPUT_FILES_BLOCK_ID))
4154       return true;
4155
4156     // Read the abbreviations
4157     while (true) {
4158       uint64_t Offset = InputFilesCursor.GetCurrentBitNo();
4159       unsigned Code = InputFilesCursor.ReadCode();
4160
4161       // We expect all abbrevs to be at the start of the block.
4162       if (Code != llvm::bitc::DEFINE_ABBREV) {
4163         InputFilesCursor.JumpToBit(Offset);
4164         break;
4165       }
4166       InputFilesCursor.ReadAbbrevRecord();
4167     }
4168   }
4169
4170   // Scan for ORIGINAL_FILE inside the control block.
4171   RecordData Record;
4172   while (1) {
4173     llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4174     if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4175       return false;
4176
4177     if (Entry.Kind != llvm::BitstreamEntry::Record)
4178       return true;
4179
4180     Record.clear();
4181     StringRef Blob;
4182     unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4183     switch ((ControlRecordTypes)RecCode) {
4184     case METADATA: {
4185       if (Record[0] != VERSION_MAJOR)
4186         return true;
4187
4188       if (Listener.ReadFullVersionInformation(Blob))
4189         return true;
4190
4191       break;
4192     }
4193     case MODULE_NAME:
4194       Listener.ReadModuleName(Blob);
4195       break;
4196     case MODULE_MAP_FILE: {
4197       unsigned Idx = 0;
4198       Listener.ReadModuleMapFile(ReadString(Record, Idx));
4199       break;
4200     }
4201     case LANGUAGE_OPTIONS:
4202       if (ParseLanguageOptions(Record, false, Listener))
4203         return true;
4204       break;
4205
4206     case TARGET_OPTIONS:
4207       if (ParseTargetOptions(Record, false, Listener))
4208         return true;
4209       break;
4210
4211     case DIAGNOSTIC_OPTIONS:
4212       if (ParseDiagnosticOptions(Record, false, Listener))
4213         return true;
4214       break;
4215
4216     case FILE_SYSTEM_OPTIONS:
4217       if (ParseFileSystemOptions(Record, false, Listener))
4218         return true;
4219       break;
4220
4221     case HEADER_SEARCH_OPTIONS:
4222       if (ParseHeaderSearchOptions(Record, false, Listener))
4223         return true;
4224       break;
4225
4226     case PREPROCESSOR_OPTIONS: {
4227       std::string IgnoredSuggestedPredefines;
4228       if (ParsePreprocessorOptions(Record, false, Listener,
4229                                    IgnoredSuggestedPredefines))
4230         return true;
4231       break;
4232     }
4233
4234     case INPUT_FILE_OFFSETS: {
4235       if (!NeedsInputFiles)
4236         break;
4237
4238       unsigned NumInputFiles = Record[0];
4239       unsigned NumUserFiles = Record[1];
4240       const uint32_t *InputFileOffs = (const uint32_t *)Blob.data();
4241       for (unsigned I = 0; I != NumInputFiles; ++I) {
4242         // Go find this input file.
4243         bool isSystemFile = I >= NumUserFiles;
4244
4245         if (isSystemFile && !NeedsSystemInputFiles)
4246           break; // the rest are system input files
4247
4248         BitstreamCursor &Cursor = InputFilesCursor;
4249         SavedStreamPosition SavedPosition(Cursor);
4250         Cursor.JumpToBit(InputFileOffs[I]);
4251
4252         unsigned Code = Cursor.ReadCode();
4253         RecordData Record;
4254         StringRef Blob;
4255         bool shouldContinue = false;
4256         switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4257         case INPUT_FILE:
4258           bool Overridden = static_cast<bool>(Record[3]);
4259           shouldContinue = Listener.visitInputFile(Blob, isSystemFile, Overridden);
4260           break;
4261         }
4262         if (!shouldContinue)
4263           break;
4264       }
4265       break;
4266     }
4267
4268     default:
4269       // No other validation to perform.
4270       break;
4271     }
4272   }
4273 }
4274
4275
4276 bool ASTReader::isAcceptableASTFile(StringRef Filename,
4277                                     FileManager &FileMgr,
4278                                     const LangOptions &LangOpts,
4279                                     const TargetOptions &TargetOpts,
4280                                     const PreprocessorOptions &PPOpts) {
4281   SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, FileMgr);
4282   return !readASTFileControlBlock(Filename, FileMgr, validator);
4283 }
4284
4285 ASTReader::ASTReadResult
4286 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4287   // Enter the submodule block.
4288   if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4289     Error("malformed submodule block record in AST file");
4290     return Failure;
4291   }
4292
4293   ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4294   bool First = true;
4295   Module *CurrentModule = nullptr;
4296   RecordData Record;
4297   while (true) {
4298     llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4299
4300     switch (Entry.Kind) {
4301     case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4302     case llvm::BitstreamEntry::Error:
4303       Error("malformed block record in AST file");
4304       return Failure;
4305     case llvm::BitstreamEntry::EndBlock:
4306       return Success;
4307     case llvm::BitstreamEntry::Record:
4308       // The interesting case.
4309       break;
4310     }
4311
4312     // Read a record.
4313     StringRef Blob;
4314     Record.clear();
4315     switch (F.Stream.readRecord(Entry.ID, Record, &Blob)) {
4316     default:  // Default behavior: ignore.
4317       break;
4318
4319     case SUBMODULE_DEFINITION: {
4320       if (First) {
4321         Error("missing submodule metadata record at beginning of block");
4322         return Failure;
4323       }
4324
4325       if (Record.size() < 8) {
4326         Error("malformed module definition");
4327         return Failure;
4328       }
4329
4330       StringRef Name = Blob;
4331       unsigned Idx = 0;
4332       SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4333       SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4334       bool IsFramework = Record[Idx++];
4335       bool IsExplicit = Record[Idx++];
4336       bool IsSystem = Record[Idx++];
4337       bool IsExternC = Record[Idx++];
4338       bool InferSubmodules = Record[Idx++];
4339       bool InferExplicitSubmodules = Record[Idx++];
4340       bool InferExportWildcard = Record[Idx++];
4341       bool ConfigMacrosExhaustive = Record[Idx++];
4342
4343       Module *ParentModule = nullptr;
4344       if (Parent)
4345         ParentModule = getSubmodule(Parent);
4346
4347       // Retrieve this (sub)module from the module map, creating it if
4348       // necessary.
4349       CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
4350                                                 IsExplicit).first;
4351
4352       // FIXME: set the definition loc for CurrentModule, or call
4353       // ModMap.setInferredModuleAllowedBy()
4354
4355       SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4356       if (GlobalIndex >= SubmodulesLoaded.size() ||
4357           SubmodulesLoaded[GlobalIndex]) {
4358         Error("too many submodules");
4359         return Failure;
4360       }
4361
4362       if (!ParentModule) {
4363         if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4364           if (CurFile != F.File) {
4365             if (!Diags.isDiagnosticInFlight()) {
4366               Diag(diag::err_module_file_conflict)
4367                 << CurrentModule->getTopLevelModuleName()
4368                 << CurFile->getName()
4369                 << F.File->getName();
4370             }
4371             return Failure;
4372           }
4373         }
4374
4375         CurrentModule->setASTFile(F.File);
4376       }
4377
4378       CurrentModule->IsFromModuleFile = true;
4379       CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
4380       CurrentModule->IsExternC = IsExternC;
4381       CurrentModule->InferSubmodules = InferSubmodules;
4382       CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4383       CurrentModule->InferExportWildcard = InferExportWildcard;
4384       CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
4385       if (DeserializationListener)
4386         DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4387
4388       SubmodulesLoaded[GlobalIndex] = CurrentModule;
4389
4390       // Clear out data that will be replaced by what is the module file.
4391       CurrentModule->LinkLibraries.clear();
4392       CurrentModule->ConfigMacros.clear();
4393       CurrentModule->UnresolvedConflicts.clear();
4394       CurrentModule->Conflicts.clear();
4395       break;
4396     }
4397
4398     case SUBMODULE_UMBRELLA_HEADER: {
4399       if (First) {
4400         Error("missing submodule metadata record at beginning of block");
4401         return Failure;
4402       }
4403
4404       if (!CurrentModule)
4405         break;
4406
4407       if (const FileEntry *Umbrella = PP.getFileManager().getFile(Blob)) {
4408         if (!CurrentModule->getUmbrellaHeader())
4409           ModMap.setUmbrellaHeader(CurrentModule, Umbrella);
4410         else if (CurrentModule->getUmbrellaHeader() != Umbrella) {
4411           if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4412             Error("mismatched umbrella headers in submodule");
4413           return OutOfDate;
4414         }
4415       }
4416       break;
4417     }
4418
4419     case SUBMODULE_HEADER: {
4420       if (First) {
4421         Error("missing submodule metadata record at beginning of block");
4422         return Failure;
4423       }
4424
4425       if (!CurrentModule)
4426         break;
4427
4428       // We lazily associate headers with their modules via the HeaderInfoTable.
4429       // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4430       // of complete filenames or remove it entirely.
4431       break;
4432     }
4433
4434     case SUBMODULE_EXCLUDED_HEADER: {
4435       if (First) {
4436         Error("missing submodule metadata record at beginning of block");
4437         return Failure;
4438       }
4439
4440       if (!CurrentModule)
4441         break;
4442
4443       // We lazily associate headers with their modules via the HeaderInfoTable.
4444       // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4445       // of complete filenames or remove it entirely.
4446       break;
4447     }
4448
4449     case SUBMODULE_PRIVATE_HEADER: {
4450       if (First) {
4451         Error("missing submodule metadata record at beginning of block");
4452         return Failure;
4453       }
4454
4455       if (!CurrentModule)
4456         break;
4457
4458       // We lazily associate headers with their modules via the HeaderInfoTable.
4459       // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4460       // of complete filenames or remove it entirely.
4461       break;
4462     }
4463
4464     case SUBMODULE_TOPHEADER: {
4465       if (First) {
4466         Error("missing submodule metadata record at beginning of block");
4467         return Failure;
4468       }
4469
4470       if (!CurrentModule)
4471         break;
4472
4473       CurrentModule->addTopHeaderFilename(Blob);
4474       break;
4475     }
4476
4477     case SUBMODULE_UMBRELLA_DIR: {
4478       if (First) {
4479         Error("missing submodule metadata record at beginning of block");
4480         return Failure;
4481       }
4482
4483       if (!CurrentModule)
4484         break;
4485
4486       if (const DirectoryEntry *Umbrella
4487                                   = PP.getFileManager().getDirectory(Blob)) {
4488         if (!CurrentModule->getUmbrellaDir())
4489           ModMap.setUmbrellaDir(CurrentModule, Umbrella);
4490         else if (CurrentModule->getUmbrellaDir() != Umbrella) {
4491           if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4492             Error("mismatched umbrella directories in submodule");
4493           return OutOfDate;
4494         }
4495       }
4496       break;
4497     }
4498
4499     case SUBMODULE_METADATA: {
4500       if (!First) {
4501         Error("submodule metadata record not at beginning of block");
4502         return Failure;
4503       }
4504       First = false;
4505
4506       F.BaseSubmoduleID = getTotalNumSubmodules();
4507       F.LocalNumSubmodules = Record[0];
4508       unsigned LocalBaseSubmoduleID = Record[1];
4509       if (F.LocalNumSubmodules > 0) {
4510         // Introduce the global -> local mapping for submodules within this
4511         // module.
4512         GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
4513
4514         // Introduce the local -> global mapping for submodules within this
4515         // module.
4516         F.SubmoduleRemap.insertOrReplace(
4517           std::make_pair(LocalBaseSubmoduleID,
4518                          F.BaseSubmoduleID - LocalBaseSubmoduleID));
4519       }
4520
4521       // Increase size by >= 1 so we get a unique base index in the next module.
4522       SubmodulesLoaded.resize(SubmodulesLoaded.size() +
4523                               std::max(F.LocalNumSubmodules, 1U));
4524       break;
4525     }
4526
4527     case SUBMODULE_IMPORTS: {
4528       if (First) {
4529         Error("missing submodule metadata record at beginning of block");
4530         return Failure;
4531       }
4532
4533       if (!CurrentModule)
4534         break;
4535
4536       for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
4537         UnresolvedModuleRef Unresolved;
4538         Unresolved.File = &F;
4539         Unresolved.Mod = CurrentModule;
4540         Unresolved.ID = Record[Idx];
4541         Unresolved.Kind = UnresolvedModuleRef::Import;
4542         Unresolved.IsWildcard = false;
4543         UnresolvedModuleRefs.push_back(Unresolved);
4544       }
4545       break;
4546     }
4547
4548     case SUBMODULE_EXPORTS: {
4549       if (First) {
4550         Error("missing submodule metadata record at beginning of block");
4551         return Failure;
4552       }
4553
4554       if (!CurrentModule)
4555         break;
4556
4557       for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
4558         UnresolvedModuleRef Unresolved;
4559         Unresolved.File = &F;
4560         Unresolved.Mod = CurrentModule;
4561         Unresolved.ID = Record[Idx];
4562         Unresolved.Kind = UnresolvedModuleRef::Export;
4563         Unresolved.IsWildcard = Record[Idx + 1];
4564         UnresolvedModuleRefs.push_back(Unresolved);
4565       }
4566
4567       // Once we've loaded the set of exports, there's no reason to keep
4568       // the parsed, unresolved exports around.
4569       CurrentModule->UnresolvedExports.clear();
4570       break;
4571     }
4572     case SUBMODULE_REQUIRES: {
4573       if (First) {
4574         Error("missing submodule metadata record at beginning of block");
4575         return Failure;
4576       }
4577
4578       if (!CurrentModule)
4579         break;
4580
4581       CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
4582                                     Context.getTargetInfo());
4583       break;
4584     }
4585
4586     case SUBMODULE_LINK_LIBRARY:
4587       if (First) {
4588         Error("missing submodule metadata record at beginning of block");
4589         return Failure;
4590       }
4591
4592       if (!CurrentModule)
4593         break;
4594
4595       CurrentModule->LinkLibraries.push_back(
4596                                          Module::LinkLibrary(Blob, Record[0]));
4597       break;
4598
4599     case SUBMODULE_CONFIG_MACRO:
4600       if (First) {
4601         Error("missing submodule metadata record at beginning of block");
4602         return Failure;
4603       }
4604
4605       if (!CurrentModule)
4606         break;
4607
4608       CurrentModule->ConfigMacros.push_back(Blob.str());
4609       break;
4610
4611     case SUBMODULE_CONFLICT: {
4612       if (First) {
4613         Error("missing submodule metadata record at beginning of block");
4614         return Failure;
4615       }
4616
4617       if (!CurrentModule)
4618         break;
4619
4620       UnresolvedModuleRef Unresolved;
4621       Unresolved.File = &F;
4622       Unresolved.Mod = CurrentModule;
4623       Unresolved.ID = Record[0];
4624       Unresolved.Kind = UnresolvedModuleRef::Conflict;
4625       Unresolved.IsWildcard = false;
4626       Unresolved.String = Blob;
4627       UnresolvedModuleRefs.push_back(Unresolved);
4628       break;
4629     }
4630     }
4631   }
4632 }
4633
4634 /// \brief Parse the record that corresponds to a LangOptions data
4635 /// structure.
4636 ///
4637 /// This routine parses the language options from the AST file and then gives
4638 /// them to the AST listener if one is set.
4639 ///
4640 /// \returns true if the listener deems the file unacceptable, false otherwise.
4641 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
4642                                      bool Complain,
4643                                      ASTReaderListener &Listener) {
4644   LangOptions LangOpts;
4645   unsigned Idx = 0;
4646 #define LANGOPT(Name, Bits, Default, Description) \
4647   LangOpts.Name = Record[Idx++];
4648 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4649   LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
4650 #include "clang/Basic/LangOptions.def"
4651 #define SANITIZER(NAME, ID) LangOpts.Sanitize.ID = Record[Idx++];
4652 #include "clang/Basic/Sanitizers.def"
4653
4654   ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
4655   VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
4656   LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
4657
4658   unsigned Length = Record[Idx++];
4659   LangOpts.CurrentModule.assign(Record.begin() + Idx,
4660                                 Record.begin() + Idx + Length);
4661
4662   Idx += Length;
4663
4664   // Comment options.
4665   for (unsigned N = Record[Idx++]; N; --N) {
4666     LangOpts.CommentOpts.BlockCommandNames.push_back(
4667       ReadString(Record, Idx));
4668   }
4669   LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
4670
4671   return Listener.ReadLanguageOptions(LangOpts, Complain);
4672 }
4673
4674 bool ASTReader::ParseTargetOptions(const RecordData &Record,
4675                                    bool Complain,
4676                                    ASTReaderListener &Listener) {
4677   unsigned Idx = 0;
4678   TargetOptions TargetOpts;
4679   TargetOpts.Triple = ReadString(Record, Idx);
4680   TargetOpts.CPU = ReadString(Record, Idx);
4681   TargetOpts.ABI = ReadString(Record, Idx);
4682   for (unsigned N = Record[Idx++]; N; --N) {
4683     TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
4684   }
4685   for (unsigned N = Record[Idx++]; N; --N) {
4686     TargetOpts.Features.push_back(ReadString(Record, Idx));
4687   }
4688
4689   return Listener.ReadTargetOptions(TargetOpts, Complain);
4690 }
4691
4692 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
4693                                        ASTReaderListener &Listener) {
4694   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
4695   unsigned Idx = 0;
4696 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
4697 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4698   DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
4699 #include "clang/Basic/DiagnosticOptions.def"
4700
4701   for (unsigned N = Record[Idx++]; N; --N)
4702     DiagOpts->Warnings.push_back(ReadString(Record, Idx));
4703   for (unsigned N = Record[Idx++]; N; --N)
4704     DiagOpts->Remarks.push_back(ReadString(Record, Idx));
4705
4706   return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
4707 }
4708
4709 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
4710                                        ASTReaderListener &Listener) {
4711   FileSystemOptions FSOpts;
4712   unsigned Idx = 0;
4713   FSOpts.WorkingDir = ReadString(Record, Idx);
4714   return Listener.ReadFileSystemOptions(FSOpts, Complain);
4715 }
4716
4717 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
4718                                          bool Complain,
4719                                          ASTReaderListener &Listener) {
4720   HeaderSearchOptions HSOpts;
4721   unsigned Idx = 0;
4722   HSOpts.Sysroot = ReadString(Record, Idx);
4723
4724   // Include entries.
4725   for (unsigned N = Record[Idx++]; N; --N) {
4726     std::string Path = ReadString(Record, Idx);
4727     frontend::IncludeDirGroup Group
4728       = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
4729     bool IsFramework = Record[Idx++];
4730     bool IgnoreSysRoot = Record[Idx++];
4731     HSOpts.UserEntries.push_back(
4732       HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot));
4733   }
4734
4735   // System header prefixes.
4736   for (unsigned N = Record[Idx++]; N; --N) {
4737     std::string Prefix = ReadString(Record, Idx);
4738     bool IsSystemHeader = Record[Idx++];
4739     HSOpts.SystemHeaderPrefixes.push_back(
4740       HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader));
4741   }
4742
4743   HSOpts.ResourceDir = ReadString(Record, Idx);
4744   HSOpts.ModuleCachePath = ReadString(Record, Idx);
4745   HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
4746   HSOpts.DisableModuleHash = Record[Idx++];
4747   HSOpts.UseBuiltinIncludes = Record[Idx++];
4748   HSOpts.UseStandardSystemIncludes = Record[Idx++];
4749   HSOpts.UseStandardCXXIncludes = Record[Idx++];
4750   HSOpts.UseLibcxx = Record[Idx++];
4751
4752   return Listener.ReadHeaderSearchOptions(HSOpts, Complain);
4753 }
4754
4755 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
4756                                          bool Complain,
4757                                          ASTReaderListener &Listener,
4758                                          std::string &SuggestedPredefines) {
4759   PreprocessorOptions PPOpts;
4760   unsigned Idx = 0;
4761
4762   // Macro definitions/undefs
4763   for (unsigned N = Record[Idx++]; N; --N) {
4764     std::string Macro = ReadString(Record, Idx);
4765     bool IsUndef = Record[Idx++];
4766     PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
4767   }
4768
4769   // Includes
4770   for (unsigned N = Record[Idx++]; N; --N) {
4771     PPOpts.Includes.push_back(ReadString(Record, Idx));
4772   }
4773
4774   // Macro Includes
4775   for (unsigned N = Record[Idx++]; N; --N) {
4776     PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
4777   }
4778
4779   PPOpts.UsePredefines = Record[Idx++];
4780   PPOpts.DetailedRecord = Record[Idx++];
4781   PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
4782   PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
4783   PPOpts.ObjCXXARCStandardLibrary =
4784     static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
4785   SuggestedPredefines.clear();
4786   return Listener.ReadPreprocessorOptions(PPOpts, Complain,
4787                                           SuggestedPredefines);
4788 }
4789
4790 std::pair<ModuleFile *, unsigned>
4791 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
4792   GlobalPreprocessedEntityMapType::iterator
4793   I = GlobalPreprocessedEntityMap.find(GlobalIndex);
4794   assert(I != GlobalPreprocessedEntityMap.end() &&
4795          "Corrupted global preprocessed entity map");
4796   ModuleFile *M = I->second;
4797   unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
4798   return std::make_pair(M, LocalIndex);
4799 }
4800
4801 std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
4802 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
4803   if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
4804     return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
4805                                              Mod.NumPreprocessedEntities);
4806
4807   return std::make_pair(PreprocessingRecord::iterator(),
4808                         PreprocessingRecord::iterator());
4809 }
4810
4811 std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator>
4812 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
4813   return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
4814                         ModuleDeclIterator(this, &Mod,
4815                                  Mod.FileSortedDecls + Mod.NumFileSortedDecls));
4816 }
4817
4818 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
4819   PreprocessedEntityID PPID = Index+1;
4820   std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4821   ModuleFile &M = *PPInfo.first;
4822   unsigned LocalIndex = PPInfo.second;
4823   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4824
4825   if (!PP.getPreprocessingRecord()) {
4826     Error("no preprocessing record");
4827     return nullptr;
4828   }
4829
4830   SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
4831   M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
4832
4833   llvm::BitstreamEntry Entry =
4834     M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
4835   if (Entry.Kind != llvm::BitstreamEntry::Record)
4836     return nullptr;
4837
4838   // Read the record.
4839   SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
4840                     ReadSourceLocation(M, PPOffs.End));
4841   PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
4842   StringRef Blob;
4843   RecordData Record;
4844   PreprocessorDetailRecordTypes RecType =
4845     (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
4846                                           Entry.ID, Record, &Blob);
4847   switch (RecType) {
4848   case PPD_MACRO_EXPANSION: {
4849     bool isBuiltin = Record[0];
4850     IdentifierInfo *Name = nullptr;
4851     MacroDefinition *Def = nullptr;
4852     if (isBuiltin)
4853       Name = getLocalIdentifier(M, Record[1]);
4854     else {
4855       PreprocessedEntityID
4856           GlobalID = getGlobalPreprocessedEntityID(M, Record[1]);
4857       Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1));
4858     }
4859
4860     MacroExpansion *ME;
4861     if (isBuiltin)
4862       ME = new (PPRec) MacroExpansion(Name, Range);
4863     else
4864       ME = new (PPRec) MacroExpansion(Def, Range);
4865
4866     return ME;
4867   }
4868
4869   case PPD_MACRO_DEFINITION: {
4870     // Decode the identifier info and then check again; if the macro is
4871     // still defined and associated with the identifier,
4872     IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
4873     MacroDefinition *MD
4874       = new (PPRec) MacroDefinition(II, Range);
4875
4876     if (DeserializationListener)
4877       DeserializationListener->MacroDefinitionRead(PPID, MD);
4878
4879     return MD;
4880   }
4881
4882   case PPD_INCLUSION_DIRECTIVE: {
4883     const char *FullFileNameStart = Blob.data() + Record[0];
4884     StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
4885     const FileEntry *File = nullptr;
4886     if (!FullFileName.empty())
4887       File = PP.getFileManager().getFile(FullFileName);
4888
4889     // FIXME: Stable encoding
4890     InclusionDirective::InclusionKind Kind
4891       = static_cast<InclusionDirective::InclusionKind>(Record[2]);
4892     InclusionDirective *ID
4893       = new (PPRec) InclusionDirective(PPRec, Kind,
4894                                        StringRef(Blob.data(), Record[0]),
4895                                        Record[1], Record[3],
4896                                        File,
4897                                        Range);
4898     return ID;
4899   }
4900   }
4901
4902   llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
4903 }
4904
4905 /// \brief \arg SLocMapI points at a chunk of a module that contains no
4906 /// preprocessed entities or the entities it contains are not the ones we are
4907 /// looking for. Find the next module that contains entities and return the ID
4908 /// of the first entry.
4909 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
4910                        GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
4911   ++SLocMapI;
4912   for (GlobalSLocOffsetMapType::const_iterator
4913          EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
4914     ModuleFile &M = *SLocMapI->second;
4915     if (M.NumPreprocessedEntities)
4916       return M.BasePreprocessedEntityID;
4917   }
4918
4919   return getTotalNumPreprocessedEntities();
4920 }
4921
4922 namespace {
4923
4924 template <unsigned PPEntityOffset::*PPLoc>
4925 struct PPEntityComp {
4926   const ASTReader &Reader;
4927   ModuleFile &M;
4928
4929   PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
4930
4931   bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4932     SourceLocation LHS = getLoc(L);
4933     SourceLocation RHS = getLoc(R);
4934     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4935   }
4936
4937   bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
4938     SourceLocation LHS = getLoc(L);
4939     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4940   }
4941
4942   bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
4943     SourceLocation RHS = getLoc(R);
4944     return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4945   }
4946
4947   SourceLocation getLoc(const PPEntityOffset &PPE) const {
4948     return Reader.ReadSourceLocation(M, PPE.*PPLoc);
4949   }
4950 };
4951
4952 }
4953
4954 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
4955                                                        bool EndsAfter) const {
4956   if (SourceMgr.isLocalSourceLocation(Loc))
4957     return getTotalNumPreprocessedEntities();
4958
4959   GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
4960       SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
4961   assert(SLocMapI != GlobalSLocOffsetMap.end() &&
4962          "Corrupted global sloc offset map");
4963
4964   if (SLocMapI->second->NumPreprocessedEntities == 0)
4965     return findNextPreprocessedEntity(SLocMapI);
4966
4967   ModuleFile &M = *SLocMapI->second;
4968   typedef const PPEntityOffset *pp_iterator;
4969   pp_iterator pp_begin = M.PreprocessedEntityOffsets;
4970   pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
4971
4972   size_t Count = M.NumPreprocessedEntities;
4973   size_t Half;
4974   pp_iterator First = pp_begin;
4975   pp_iterator PPI;
4976
4977   if (EndsAfter) {
4978     PPI = std::upper_bound(pp_begin, pp_end, Loc,
4979                            PPEntityComp<&PPEntityOffset::Begin>(*this, M));
4980   } else {
4981     // Do a binary search manually instead of using std::lower_bound because
4982     // The end locations of entities may be unordered (when a macro expansion
4983     // is inside another macro argument), but for this case it is not important
4984     // whether we get the first macro expansion or its containing macro.
4985     while (Count > 0) {
4986       Half = Count / 2;
4987       PPI = First;
4988       std::advance(PPI, Half);
4989       if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
4990                                               Loc)) {
4991         First = PPI;
4992         ++First;
4993         Count = Count - Half - 1;
4994       } else
4995         Count = Half;
4996     }
4997   }
4998
4999   if (PPI == pp_end)
5000     return findNextPreprocessedEntity(SLocMapI);
5001
5002   return M.BasePreprocessedEntityID + (PPI - pp_begin);
5003 }
5004
5005 /// \brief Returns a pair of [Begin, End) indices of preallocated
5006 /// preprocessed entities that \arg Range encompasses.
5007 std::pair<unsigned, unsigned>
5008     ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5009   if (Range.isInvalid())
5010     return std::make_pair(0,0);
5011   assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5012
5013   PreprocessedEntityID BeginID =
5014       findPreprocessedEntity(Range.getBegin(), false);
5015   PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5016   return std::make_pair(BeginID, EndID);
5017 }
5018
5019 /// \brief Optionally returns true or false if the preallocated preprocessed
5020 /// entity with index \arg Index came from file \arg FID.
5021 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5022                                                              FileID FID) {
5023   if (FID.isInvalid())
5024     return false;
5025
5026   std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5027   ModuleFile &M = *PPInfo.first;
5028   unsigned LocalIndex = PPInfo.second;
5029   const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5030
5031   SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
5032   if (Loc.isInvalid())
5033     return false;
5034
5035   if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5036     return true;
5037   else
5038     return false;
5039 }
5040
5041 namespace {
5042   /// \brief Visitor used to search for information about a header file.
5043   class HeaderFileInfoVisitor {
5044     const FileEntry *FE;
5045
5046     Optional<HeaderFileInfo> HFI;
5047
5048   public:
5049     explicit HeaderFileInfoVisitor(const FileEntry *FE)
5050       : FE(FE) { }
5051
5052     static bool visit(ModuleFile &M, void *UserData) {
5053       HeaderFileInfoVisitor *This
5054         = static_cast<HeaderFileInfoVisitor *>(UserData);
5055
5056       HeaderFileInfoLookupTable *Table
5057         = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5058       if (!Table)
5059         return false;
5060
5061       // Look in the on-disk hash table for an entry for this file name.
5062       HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE);
5063       if (Pos == Table->end())
5064         return false;
5065
5066       This->HFI = *Pos;
5067       return true;
5068     }
5069
5070     Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5071   };
5072 }
5073
5074 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5075   HeaderFileInfoVisitor Visitor(FE);
5076   ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
5077   if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5078     return *HFI;
5079
5080   return HeaderFileInfo();
5081 }
5082
5083 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5084   // FIXME: Make it work properly with modules.
5085   SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
5086   for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
5087     ModuleFile &F = *(*I);
5088     unsigned Idx = 0;
5089     DiagStates.clear();
5090     assert(!Diag.DiagStates.empty());
5091     DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
5092     while (Idx < F.PragmaDiagMappings.size()) {
5093       SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5094       unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
5095       if (DiagStateID != 0) {
5096         Diag.DiagStatePoints.push_back(
5097                     DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
5098                     FullSourceLoc(Loc, SourceMgr)));
5099         continue;
5100       }
5101
5102       assert(DiagStateID == 0);
5103       // A new DiagState was created here.
5104       Diag.DiagStates.push_back(*Diag.GetCurDiagState());
5105       DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
5106       DiagStates.push_back(NewState);
5107       Diag.DiagStatePoints.push_back(
5108           DiagnosticsEngine::DiagStatePoint(NewState,
5109                                             FullSourceLoc(Loc, SourceMgr)));
5110       while (1) {
5111         assert(Idx < F.PragmaDiagMappings.size() &&
5112                "Invalid data, didn't find '-1' marking end of diag/map pairs");
5113         if (Idx >= F.PragmaDiagMappings.size()) {
5114           break; // Something is messed up but at least avoid infinite loop in
5115                  // release build.
5116         }
5117         unsigned DiagID = F.PragmaDiagMappings[Idx++];
5118         if (DiagID == (unsigned)-1) {
5119           break; // no more diag/map pairs for this location.
5120         }
5121         diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
5122         DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
5123         Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
5124       }
5125     }
5126   }
5127 }
5128
5129 /// \brief Get the correct cursor and offset for loading a type.
5130 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5131   GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5132   assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5133   ModuleFile *M = I->second;
5134   return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5135 }
5136
5137 /// \brief Read and return the type with the given index..
5138 ///
5139 /// The index is the type ID, shifted and minus the number of predefs. This
5140 /// routine actually reads the record corresponding to the type at the given
5141 /// location. It is a helper routine for GetType, which deals with reading type
5142 /// IDs.
5143 QualType ASTReader::readTypeRecord(unsigned Index) {
5144   RecordLocation Loc = TypeCursorForIndex(Index);
5145   BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5146
5147   // Keep track of where we are in the stream, then jump back there
5148   // after reading this type.
5149   SavedStreamPosition SavedPosition(DeclsCursor);
5150
5151   ReadingKindTracker ReadingKind(Read_Type, *this);
5152
5153   // Note that we are loading a type record.
5154   Deserializing AType(this);
5155
5156   unsigned Idx = 0;
5157   DeclsCursor.JumpToBit(Loc.Offset);
5158   RecordData Record;
5159   unsigned Code = DeclsCursor.ReadCode();
5160   switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5161   case TYPE_EXT_QUAL: {
5162     if (Record.size() != 2) {
5163       Error("Incorrect encoding of extended qualifier type");
5164       return QualType();
5165     }
5166     QualType Base = readType(*Loc.F, Record, Idx);
5167     Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5168     return Context.getQualifiedType(Base, Quals);
5169   }
5170
5171   case TYPE_COMPLEX: {
5172     if (Record.size() != 1) {
5173       Error("Incorrect encoding of complex type");
5174       return QualType();
5175     }
5176     QualType ElemType = readType(*Loc.F, Record, Idx);
5177     return Context.getComplexType(ElemType);
5178   }
5179
5180   case TYPE_POINTER: {
5181     if (Record.size() != 1) {
5182       Error("Incorrect encoding of pointer type");
5183       return QualType();
5184     }
5185     QualType PointeeType = readType(*Loc.F, Record, Idx);
5186     return Context.getPointerType(PointeeType);
5187   }
5188
5189   case TYPE_DECAYED: {
5190     if (Record.size() != 1) {
5191       Error("Incorrect encoding of decayed type");
5192       return QualType();
5193     }
5194     QualType OriginalType = readType(*Loc.F, Record, Idx);
5195     QualType DT = Context.getAdjustedParameterType(OriginalType);
5196     if (!isa<DecayedType>(DT))
5197       Error("Decayed type does not decay");
5198     return DT;
5199   }
5200
5201   case TYPE_ADJUSTED: {
5202     if (Record.size() != 2) {
5203       Error("Incorrect encoding of adjusted type");
5204       return QualType();
5205     }
5206     QualType OriginalTy = readType(*Loc.F, Record, Idx);
5207     QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5208     return Context.getAdjustedType(OriginalTy, AdjustedTy);
5209   }
5210
5211   case TYPE_BLOCK_POINTER: {
5212     if (Record.size() != 1) {
5213       Error("Incorrect encoding of block pointer type");
5214       return QualType();
5215     }
5216     QualType PointeeType = readType(*Loc.F, Record, Idx);
5217     return Context.getBlockPointerType(PointeeType);
5218   }
5219
5220   case TYPE_LVALUE_REFERENCE: {
5221     if (Record.size() != 2) {
5222       Error("Incorrect encoding of lvalue reference type");
5223       return QualType();
5224     }
5225     QualType PointeeType = readType(*Loc.F, Record, Idx);
5226     return Context.getLValueReferenceType(PointeeType, Record[1]);
5227   }
5228
5229   case TYPE_RVALUE_REFERENCE: {
5230     if (Record.size() != 1) {
5231       Error("Incorrect encoding of rvalue reference type");
5232       return QualType();
5233     }
5234     QualType PointeeType = readType(*Loc.F, Record, Idx);
5235     return Context.getRValueReferenceType(PointeeType);
5236   }
5237
5238   case TYPE_MEMBER_POINTER: {
5239     if (Record.size() != 2) {
5240       Error("Incorrect encoding of member pointer type");
5241       return QualType();
5242     }
5243     QualType PointeeType = readType(*Loc.F, Record, Idx);
5244     QualType ClassType = readType(*Loc.F, Record, Idx);
5245     if (PointeeType.isNull() || ClassType.isNull())
5246       return QualType();
5247
5248     return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5249   }
5250
5251   case TYPE_CONSTANT_ARRAY: {
5252     QualType ElementType = readType(*Loc.F, Record, Idx);
5253     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5254     unsigned IndexTypeQuals = Record[2];
5255     unsigned Idx = 3;
5256     llvm::APInt Size = ReadAPInt(Record, Idx);
5257     return Context.getConstantArrayType(ElementType, Size,
5258                                          ASM, IndexTypeQuals);
5259   }
5260
5261   case TYPE_INCOMPLETE_ARRAY: {
5262     QualType ElementType = readType(*Loc.F, Record, Idx);
5263     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5264     unsigned IndexTypeQuals = Record[2];
5265     return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5266   }
5267
5268   case TYPE_VARIABLE_ARRAY: {
5269     QualType ElementType = readType(*Loc.F, Record, Idx);
5270     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5271     unsigned IndexTypeQuals = Record[2];
5272     SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5273     SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5274     return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5275                                          ASM, IndexTypeQuals,
5276                                          SourceRange(LBLoc, RBLoc));
5277   }
5278
5279   case TYPE_VECTOR: {
5280     if (Record.size() != 3) {
5281       Error("incorrect encoding of vector type in AST file");
5282       return QualType();
5283     }
5284
5285     QualType ElementType = readType(*Loc.F, Record, Idx);
5286     unsigned NumElements = Record[1];
5287     unsigned VecKind = Record[2];
5288     return Context.getVectorType(ElementType, NumElements,
5289                                   (VectorType::VectorKind)VecKind);
5290   }
5291
5292   case TYPE_EXT_VECTOR: {
5293     if (Record.size() != 3) {
5294       Error("incorrect encoding of extended vector type in AST file");
5295       return QualType();
5296     }
5297
5298     QualType ElementType = readType(*Loc.F, Record, Idx);
5299     unsigned NumElements = Record[1];
5300     return Context.getExtVectorType(ElementType, NumElements);
5301   }
5302
5303   case TYPE_FUNCTION_NO_PROTO: {
5304     if (Record.size() != 6) {
5305       Error("incorrect encoding of no-proto function type");
5306       return QualType();
5307     }
5308     QualType ResultType = readType(*Loc.F, Record, Idx);
5309     FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5310                                (CallingConv)Record[4], Record[5]);
5311     return Context.getFunctionNoProtoType(ResultType, Info);
5312   }
5313
5314   case TYPE_FUNCTION_PROTO: {
5315     QualType ResultType = readType(*Loc.F, Record, Idx);
5316
5317     FunctionProtoType::ExtProtoInfo EPI;
5318     EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5319                                         /*hasregparm*/ Record[2],
5320                                         /*regparm*/ Record[3],
5321                                         static_cast<CallingConv>(Record[4]),
5322                                         /*produces*/ Record[5]);
5323
5324     unsigned Idx = 6;
5325
5326     EPI.Variadic = Record[Idx++];
5327     EPI.HasTrailingReturn = Record[Idx++];
5328     EPI.TypeQuals = Record[Idx++];
5329     EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5330     SmallVector<QualType, 8> ExceptionStorage;
5331     readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
5332
5333     unsigned NumParams = Record[Idx++];
5334     SmallVector<QualType, 16> ParamTypes;
5335     for (unsigned I = 0; I != NumParams; ++I)
5336       ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5337
5338     return Context.getFunctionType(ResultType, ParamTypes, EPI);
5339   }
5340
5341   case TYPE_UNRESOLVED_USING: {
5342     unsigned Idx = 0;
5343     return Context.getTypeDeclType(
5344                   ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5345   }
5346
5347   case TYPE_TYPEDEF: {
5348     if (Record.size() != 2) {
5349       Error("incorrect encoding of typedef type");
5350       return QualType();
5351     }
5352     unsigned Idx = 0;
5353     TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5354     QualType Canonical = readType(*Loc.F, Record, Idx);
5355     if (!Canonical.isNull())
5356       Canonical = Context.getCanonicalType(Canonical);
5357     return Context.getTypedefType(Decl, Canonical);
5358   }
5359
5360   case TYPE_TYPEOF_EXPR:
5361     return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5362
5363   case TYPE_TYPEOF: {
5364     if (Record.size() != 1) {
5365       Error("incorrect encoding of typeof(type) in AST file");
5366       return QualType();
5367     }
5368     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5369     return Context.getTypeOfType(UnderlyingType);
5370   }
5371
5372   case TYPE_DECLTYPE: {
5373     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5374     return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5375   }
5376
5377   case TYPE_UNARY_TRANSFORM: {
5378     QualType BaseType = readType(*Loc.F, Record, Idx);
5379     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5380     UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
5381     return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5382   }
5383
5384   case TYPE_AUTO: {
5385     QualType Deduced = readType(*Loc.F, Record, Idx);
5386     bool IsDecltypeAuto = Record[Idx++];
5387     bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
5388     return Context.getAutoType(Deduced, IsDecltypeAuto, IsDependent);
5389   }
5390
5391   case TYPE_RECORD: {
5392     if (Record.size() != 2) {
5393       Error("incorrect encoding of record type");
5394       return QualType();
5395     }
5396     unsigned Idx = 0;
5397     bool IsDependent = Record[Idx++];
5398     RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
5399     RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
5400     QualType T = Context.getRecordType(RD);
5401     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5402     return T;
5403   }
5404
5405   case TYPE_ENUM: {
5406     if (Record.size() != 2) {
5407       Error("incorrect encoding of enum type");
5408       return QualType();
5409     }
5410     unsigned Idx = 0;
5411     bool IsDependent = Record[Idx++];
5412     QualType T
5413       = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
5414     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5415     return T;
5416   }
5417
5418   case TYPE_ATTRIBUTED: {
5419     if (Record.size() != 3) {
5420       Error("incorrect encoding of attributed type");
5421       return QualType();
5422     }
5423     QualType modifiedType = readType(*Loc.F, Record, Idx);
5424     QualType equivalentType = readType(*Loc.F, Record, Idx);
5425     AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
5426     return Context.getAttributedType(kind, modifiedType, equivalentType);
5427   }
5428
5429   case TYPE_PAREN: {
5430     if (Record.size() != 1) {
5431       Error("incorrect encoding of paren type");
5432       return QualType();
5433     }
5434     QualType InnerType = readType(*Loc.F, Record, Idx);
5435     return Context.getParenType(InnerType);
5436   }
5437
5438   case TYPE_PACK_EXPANSION: {
5439     if (Record.size() != 2) {
5440       Error("incorrect encoding of pack expansion type");
5441       return QualType();
5442     }
5443     QualType Pattern = readType(*Loc.F, Record, Idx);
5444     if (Pattern.isNull())
5445       return QualType();
5446     Optional<unsigned> NumExpansions;
5447     if (Record[1])
5448       NumExpansions = Record[1] - 1;
5449     return Context.getPackExpansionType(Pattern, NumExpansions);
5450   }
5451
5452   case TYPE_ELABORATED: {
5453     unsigned Idx = 0;
5454     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5455     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5456     QualType NamedType = readType(*Loc.F, Record, Idx);
5457     return Context.getElaboratedType(Keyword, NNS, NamedType);
5458   }
5459
5460   case TYPE_OBJC_INTERFACE: {
5461     unsigned Idx = 0;
5462     ObjCInterfaceDecl *ItfD
5463       = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
5464     return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
5465   }
5466
5467   case TYPE_OBJC_OBJECT: {
5468     unsigned Idx = 0;
5469     QualType Base = readType(*Loc.F, Record, Idx);
5470     unsigned NumProtos = Record[Idx++];
5471     SmallVector<ObjCProtocolDecl*, 4> Protos;
5472     for (unsigned I = 0; I != NumProtos; ++I)
5473       Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
5474     return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
5475   }
5476
5477   case TYPE_OBJC_OBJECT_POINTER: {
5478     unsigned Idx = 0;
5479     QualType Pointee = readType(*Loc.F, Record, Idx);
5480     return Context.getObjCObjectPointerType(Pointee);
5481   }
5482
5483   case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
5484     unsigned Idx = 0;
5485     QualType Parm = readType(*Loc.F, Record, Idx);
5486     QualType Replacement = readType(*Loc.F, Record, Idx);
5487     return Context.getSubstTemplateTypeParmType(
5488         cast<TemplateTypeParmType>(Parm),
5489         Context.getCanonicalType(Replacement));
5490   }
5491
5492   case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
5493     unsigned Idx = 0;
5494     QualType Parm = readType(*Loc.F, Record, Idx);
5495     TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
5496     return Context.getSubstTemplateTypeParmPackType(
5497                                                cast<TemplateTypeParmType>(Parm),
5498                                                      ArgPack);
5499   }
5500
5501   case TYPE_INJECTED_CLASS_NAME: {
5502     CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
5503     QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
5504     // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
5505     // for AST reading, too much interdependencies.
5506     const Type *T;
5507     if (const Type *Existing = D->getTypeForDecl())
5508       T = Existing;
5509     else if (auto *Prev = D->getPreviousDecl())
5510       T = Prev->getTypeForDecl();
5511     else
5512       T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
5513     return QualType(T, 0);
5514   }
5515
5516   case TYPE_TEMPLATE_TYPE_PARM: {
5517     unsigned Idx = 0;
5518     unsigned Depth = Record[Idx++];
5519     unsigned Index = Record[Idx++];
5520     bool Pack = Record[Idx++];
5521     TemplateTypeParmDecl *D
5522       = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
5523     return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
5524   }
5525
5526   case TYPE_DEPENDENT_NAME: {
5527     unsigned Idx = 0;
5528     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5529     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5530     const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
5531     QualType Canon = readType(*Loc.F, Record, Idx);
5532     if (!Canon.isNull())
5533       Canon = Context.getCanonicalType(Canon);
5534     return Context.getDependentNameType(Keyword, NNS, Name, Canon);
5535   }
5536
5537   case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
5538     unsigned Idx = 0;
5539     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5540     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5541     const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
5542     unsigned NumArgs = Record[Idx++];
5543     SmallVector<TemplateArgument, 8> Args;
5544     Args.reserve(NumArgs);
5545     while (NumArgs--)
5546       Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
5547     return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
5548                                                       Args.size(), Args.data());
5549   }
5550
5551   case TYPE_DEPENDENT_SIZED_ARRAY: {
5552     unsigned Idx = 0;
5553
5554     // ArrayType
5555     QualType ElementType = readType(*Loc.F, Record, Idx);
5556     ArrayType::ArraySizeModifier ASM
5557       = (ArrayType::ArraySizeModifier)Record[Idx++];
5558     unsigned IndexTypeQuals = Record[Idx++];
5559
5560     // DependentSizedArrayType
5561     Expr *NumElts = ReadExpr(*Loc.F);
5562     SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
5563
5564     return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
5565                                                IndexTypeQuals, Brackets);
5566   }
5567
5568   case TYPE_TEMPLATE_SPECIALIZATION: {
5569     unsigned Idx = 0;
5570     bool IsDependent = Record[Idx++];
5571     TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
5572     SmallVector<TemplateArgument, 8> Args;
5573     ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
5574     QualType Underlying = readType(*Loc.F, Record, Idx);
5575     QualType T;
5576     if (Underlying.isNull())
5577       T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
5578                                                           Args.size());
5579     else
5580       T = Context.getTemplateSpecializationType(Name, Args.data(),
5581                                                  Args.size(), Underlying);
5582     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5583     return T;
5584   }
5585
5586   case TYPE_ATOMIC: {
5587     if (Record.size() != 1) {
5588       Error("Incorrect encoding of atomic type");
5589       return QualType();
5590     }
5591     QualType ValueType = readType(*Loc.F, Record, Idx);
5592     return Context.getAtomicType(ValueType);
5593   }
5594   }
5595   llvm_unreachable("Invalid TypeCode!");
5596 }
5597
5598 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
5599                                   SmallVectorImpl<QualType> &Exceptions,
5600                                   FunctionProtoType::ExceptionSpecInfo &ESI,
5601                                   const RecordData &Record, unsigned &Idx) {
5602   ExceptionSpecificationType EST =
5603       static_cast<ExceptionSpecificationType>(Record[Idx++]);
5604   ESI.Type = EST;
5605   if (EST == EST_Dynamic) {
5606     for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
5607       Exceptions.push_back(readType(ModuleFile, Record, Idx));
5608     ESI.Exceptions = Exceptions;
5609   } else if (EST == EST_ComputedNoexcept) {
5610     ESI.NoexceptExpr = ReadExpr(ModuleFile);
5611   } else if (EST == EST_Uninstantiated) {
5612     ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5613     ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5614   } else if (EST == EST_Unevaluated) {
5615     ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5616   }
5617 }
5618
5619 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
5620   ASTReader &Reader;
5621   ModuleFile &F;
5622   const ASTReader::RecordData &Record;
5623   unsigned &Idx;
5624
5625   SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
5626                                     unsigned &I) {
5627     return Reader.ReadSourceLocation(F, R, I);
5628   }
5629
5630   template<typename T>
5631   T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
5632     return Reader.ReadDeclAs<T>(F, Record, Idx);
5633   }
5634
5635 public:
5636   TypeLocReader(ASTReader &Reader, ModuleFile &F,
5637                 const ASTReader::RecordData &Record, unsigned &Idx)
5638     : Reader(Reader), F(F), Record(Record), Idx(Idx)
5639   { }
5640
5641   // We want compile-time assurance that we've enumerated all of
5642   // these, so unfortunately we have to declare them first, then
5643   // define them out-of-line.
5644 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5645 #define TYPELOC(CLASS, PARENT) \
5646   void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
5647 #include "clang/AST/TypeLocNodes.def"
5648
5649   void VisitFunctionTypeLoc(FunctionTypeLoc);
5650   void VisitArrayTypeLoc(ArrayTypeLoc);
5651 };
5652
5653 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5654   // nothing to do
5655 }
5656 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5657   TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
5658   if (TL.needsExtraLocalData()) {
5659     TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
5660     TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
5661     TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
5662     TL.setModeAttr(Record[Idx++]);
5663   }
5664 }
5665 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
5666   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5667 }
5668 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
5669   TL.setStarLoc(ReadSourceLocation(Record, Idx));
5670 }
5671 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5672   // nothing to do
5673 }
5674 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5675   // nothing to do
5676 }
5677 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5678   TL.setCaretLoc(ReadSourceLocation(Record, Idx));
5679 }
5680 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5681   TL.setAmpLoc(ReadSourceLocation(Record, Idx));
5682 }
5683 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5684   TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
5685 }
5686 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5687   TL.setStarLoc(ReadSourceLocation(Record, Idx));
5688   TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5689 }
5690 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
5691   TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
5692   TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
5693   if (Record[Idx++])
5694     TL.setSizeExpr(Reader.ReadExpr(F));
5695   else
5696     TL.setSizeExpr(nullptr);
5697 }
5698 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
5699   VisitArrayTypeLoc(TL);
5700 }
5701 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
5702   VisitArrayTypeLoc(TL);
5703 }
5704 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
5705   VisitArrayTypeLoc(TL);
5706 }
5707 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
5708                                             DependentSizedArrayTypeLoc TL) {
5709   VisitArrayTypeLoc(TL);
5710 }
5711 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
5712                                         DependentSizedExtVectorTypeLoc TL) {
5713   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5714 }
5715 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
5716   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5717 }
5718 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
5719   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5720 }
5721 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5722   TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
5723   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5724   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5725   TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
5726   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
5727     TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
5728   }
5729 }
5730 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
5731   VisitFunctionTypeLoc(TL);
5732 }
5733 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
5734   VisitFunctionTypeLoc(TL);
5735 }
5736 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5737   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5738 }
5739 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5740   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5741 }
5742 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5743   TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5744   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5745   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5746 }
5747 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5748   TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5749   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5750   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5751   TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5752 }
5753 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
5754   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5755 }
5756 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5757   TL.setKWLoc(ReadSourceLocation(Record, Idx));
5758   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5759   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5760   TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5761 }
5762 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
5763   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5764 }
5765 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
5766   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5767 }
5768 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
5769   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5770 }
5771 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5772   TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
5773   if (TL.hasAttrOperand()) {
5774     SourceRange range;
5775     range.setBegin(ReadSourceLocation(Record, Idx));
5776     range.setEnd(ReadSourceLocation(Record, Idx));
5777     TL.setAttrOperandParensRange(range);
5778   }
5779   if (TL.hasAttrExprOperand()) {
5780     if (Record[Idx++])
5781       TL.setAttrExprOperand(Reader.ReadExpr(F));
5782     else
5783       TL.setAttrExprOperand(nullptr);
5784   } else if (TL.hasAttrEnumOperand())
5785     TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
5786 }
5787 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
5788   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5789 }
5790 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
5791                                             SubstTemplateTypeParmTypeLoc TL) {
5792   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5793 }
5794 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
5795                                           SubstTemplateTypeParmPackTypeLoc TL) {
5796   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5797 }
5798 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
5799                                            TemplateSpecializationTypeLoc TL) {
5800   TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5801   TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5802   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5803   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5804   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
5805     TL.setArgLocInfo(i,
5806         Reader.GetTemplateArgumentLocInfo(F,
5807                                           TL.getTypePtr()->getArg(i).getKind(),
5808                                           Record, Idx));
5809 }
5810 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
5811   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5812   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5813 }
5814 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5815   TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5816   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5817 }
5818 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
5819   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5820 }
5821 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5822   TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5823   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5824   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5825 }
5826 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
5827        DependentTemplateSpecializationTypeLoc TL) {
5828   TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5829   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5830   TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5831   TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5832   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5833   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5834   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
5835     TL.setArgLocInfo(I,
5836         Reader.GetTemplateArgumentLocInfo(F,
5837                                           TL.getTypePtr()->getArg(I).getKind(),
5838                                           Record, Idx));
5839 }
5840 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
5841   TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
5842 }
5843 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5844   TL.setNameLoc(ReadSourceLocation(Record, Idx));
5845 }
5846 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5847   TL.setHasBaseTypeAsWritten(Record[Idx++]);
5848   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5849   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5850   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
5851     TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
5852 }
5853 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5854   TL.setStarLoc(ReadSourceLocation(Record, Idx));
5855 }
5856 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5857   TL.setKWLoc(ReadSourceLocation(Record, Idx));
5858   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5859   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5860 }
5861
5862 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
5863                                              const RecordData &Record,
5864                                              unsigned &Idx) {
5865   QualType InfoTy = readType(F, Record, Idx);
5866   if (InfoTy.isNull())
5867     return nullptr;
5868
5869   TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
5870   TypeLocReader TLR(*this, F, Record, Idx);
5871   for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
5872     TLR.Visit(TL);
5873   return TInfo;
5874 }
5875
5876 QualType ASTReader::GetType(TypeID ID) {
5877   unsigned FastQuals = ID & Qualifiers::FastMask;
5878   unsigned Index = ID >> Qualifiers::FastWidth;
5879
5880   if (Index < NUM_PREDEF_TYPE_IDS) {
5881     QualType T;
5882     switch ((PredefinedTypeIDs)Index) {
5883     case PREDEF_TYPE_NULL_ID: return QualType();
5884     case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
5885     case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
5886
5887     case PREDEF_TYPE_CHAR_U_ID:
5888     case PREDEF_TYPE_CHAR_S_ID:
5889       // FIXME: Check that the signedness of CharTy is correct!
5890       T = Context.CharTy;
5891       break;
5892
5893     case PREDEF_TYPE_UCHAR_ID:      T = Context.UnsignedCharTy;     break;
5894     case PREDEF_TYPE_USHORT_ID:     T = Context.UnsignedShortTy;    break;
5895     case PREDEF_TYPE_UINT_ID:       T = Context.UnsignedIntTy;      break;
5896     case PREDEF_TYPE_ULONG_ID:      T = Context.UnsignedLongTy;     break;
5897     case PREDEF_TYPE_ULONGLONG_ID:  T = Context.UnsignedLongLongTy; break;
5898     case PREDEF_TYPE_UINT128_ID:    T = Context.UnsignedInt128Ty;   break;
5899     case PREDEF_TYPE_SCHAR_ID:      T = Context.SignedCharTy;       break;
5900     case PREDEF_TYPE_WCHAR_ID:      T = Context.WCharTy;            break;
5901     case PREDEF_TYPE_SHORT_ID:      T = Context.ShortTy;            break;
5902     case PREDEF_TYPE_INT_ID:        T = Context.IntTy;              break;
5903     case PREDEF_TYPE_LONG_ID:       T = Context.LongTy;             break;
5904     case PREDEF_TYPE_LONGLONG_ID:   T = Context.LongLongTy;         break;
5905     case PREDEF_TYPE_INT128_ID:     T = Context.Int128Ty;           break;
5906     case PREDEF_TYPE_HALF_ID:       T = Context.HalfTy;             break;
5907     case PREDEF_TYPE_FLOAT_ID:      T = Context.FloatTy;            break;
5908     case PREDEF_TYPE_DOUBLE_ID:     T = Context.DoubleTy;           break;
5909     case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy;       break;
5910     case PREDEF_TYPE_OVERLOAD_ID:   T = Context.OverloadTy;         break;
5911     case PREDEF_TYPE_BOUND_MEMBER:  T = Context.BoundMemberTy;      break;
5912     case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy;     break;
5913     case PREDEF_TYPE_DEPENDENT_ID:  T = Context.DependentTy;        break;
5914     case PREDEF_TYPE_UNKNOWN_ANY:   T = Context.UnknownAnyTy;       break;
5915     case PREDEF_TYPE_NULLPTR_ID:    T = Context.NullPtrTy;          break;
5916     case PREDEF_TYPE_CHAR16_ID:     T = Context.Char16Ty;           break;
5917     case PREDEF_TYPE_CHAR32_ID:     T = Context.Char32Ty;           break;
5918     case PREDEF_TYPE_OBJC_ID:       T = Context.ObjCBuiltinIdTy;    break;
5919     case PREDEF_TYPE_OBJC_CLASS:    T = Context.ObjCBuiltinClassTy; break;
5920     case PREDEF_TYPE_OBJC_SEL:      T = Context.ObjCBuiltinSelTy;   break;
5921     case PREDEF_TYPE_IMAGE1D_ID:    T = Context.OCLImage1dTy;       break;
5922     case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break;
5923     case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break;
5924     case PREDEF_TYPE_IMAGE2D_ID:    T = Context.OCLImage2dTy;       break;
5925     case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break;
5926     case PREDEF_TYPE_IMAGE3D_ID:    T = Context.OCLImage3dTy;       break;
5927     case PREDEF_TYPE_SAMPLER_ID:    T = Context.OCLSamplerTy;       break;
5928     case PREDEF_TYPE_EVENT_ID:      T = Context.OCLEventTy;         break;
5929     case PREDEF_TYPE_AUTO_DEDUCT:   T = Context.getAutoDeductType(); break;
5930
5931     case PREDEF_TYPE_AUTO_RREF_DEDUCT:
5932       T = Context.getAutoRRefDeductType();
5933       break;
5934
5935     case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
5936       T = Context.ARCUnbridgedCastTy;
5937       break;
5938
5939     case PREDEF_TYPE_VA_LIST_TAG:
5940       T = Context.getVaListTagType();
5941       break;
5942
5943     case PREDEF_TYPE_BUILTIN_FN:
5944       T = Context.BuiltinFnTy;
5945       break;
5946     }
5947
5948     assert(!T.isNull() && "Unknown predefined type");
5949     return T.withFastQualifiers(FastQuals);
5950   }
5951
5952   Index -= NUM_PREDEF_TYPE_IDS;
5953   assert(Index < TypesLoaded.size() && "Type index out-of-range");
5954   if (TypesLoaded[Index].isNull()) {
5955     TypesLoaded[Index] = readTypeRecord(Index);
5956     if (TypesLoaded[Index].isNull())
5957       return QualType();
5958
5959     TypesLoaded[Index]->setFromAST();
5960     if (DeserializationListener)
5961       DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
5962                                         TypesLoaded[Index]);
5963   }
5964
5965   return TypesLoaded[Index].withFastQualifiers(FastQuals);
5966 }
5967
5968 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
5969   return GetType(getGlobalTypeID(F, LocalID));
5970 }
5971
5972 serialization::TypeID
5973 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
5974   unsigned FastQuals = LocalID & Qualifiers::FastMask;
5975   unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
5976
5977   if (LocalIndex < NUM_PREDEF_TYPE_IDS)
5978     return LocalID;
5979
5980   ContinuousRangeMap<uint32_t, int, 2>::iterator I
5981     = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
5982   assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
5983
5984   unsigned GlobalIndex = LocalIndex + I->second;
5985   return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
5986 }
5987
5988 TemplateArgumentLocInfo
5989 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
5990                                       TemplateArgument::ArgKind Kind,
5991                                       const RecordData &Record,
5992                                       unsigned &Index) {
5993   switch (Kind) {
5994   case TemplateArgument::Expression:
5995     return ReadExpr(F);
5996   case TemplateArgument::Type:
5997     return GetTypeSourceInfo(F, Record, Index);
5998   case TemplateArgument::Template: {
5999     NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6000                                                                      Index);
6001     SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6002     return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6003                                    SourceLocation());
6004   }
6005   case TemplateArgument::TemplateExpansion: {
6006     NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6007                                                                      Index);
6008     SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6009     SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6010     return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6011                                    EllipsisLoc);
6012   }
6013   case TemplateArgument::Null:
6014   case TemplateArgument::Integral:
6015   case TemplateArgument::Declaration:
6016   case TemplateArgument::NullPtr:
6017   case TemplateArgument::Pack:
6018     // FIXME: Is this right?
6019     return TemplateArgumentLocInfo();
6020   }
6021   llvm_unreachable("unexpected template argument loc");
6022 }
6023
6024 TemplateArgumentLoc
6025 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
6026                                    const RecordData &Record, unsigned &Index) {
6027   TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6028
6029   if (Arg.getKind() == TemplateArgument::Expression) {
6030     if (Record[Index++]) // bool InfoHasSameExpr.
6031       return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
6032   }
6033   return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6034                                                              Record, Index));
6035 }
6036
6037 const ASTTemplateArgumentListInfo*
6038 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
6039                                            const RecordData &Record,
6040                                            unsigned &Index) {
6041   SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6042   SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6043   unsigned NumArgsAsWritten = Record[Index++];
6044   TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6045   for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6046     TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6047   return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6048 }
6049
6050 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6051   return GetDecl(ID);
6052 }
6053
6054 void ASTReader::CompleteRedeclChain(const Decl *D) {
6055   if (NumCurrentElementsDeserializing) {
6056     // We arrange to not care about the complete redeclaration chain while we're
6057     // deserializing. Just remember that the AST has marked this one as complete
6058     // but that it's not actually complete yet, so we know we still need to
6059     // complete it later.
6060     PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6061     return;
6062   }
6063
6064   const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6065
6066   // If this is a named declaration, complete it by looking it up
6067   // within its context.
6068   //
6069   // FIXME: We don't currently handle the cases where we can't do this;
6070   // merging a class definition that contains unnamed entities should merge
6071   // those entities. Likewise, merging a function definition should merge
6072   // all mergeable entities within it.
6073   if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6074       isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6075     if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6076       auto *II = Name.getAsIdentifierInfo();
6077       if (isa<TranslationUnitDecl>(DC) && II) {
6078         // Outside of C++, we don't have a lookup table for the TU, so update
6079         // the identifier instead. In C++, either way should work fine.
6080         if (II->isOutOfDate())
6081           updateOutOfDateIdentifier(*II);
6082       } else
6083         DC->lookup(Name);
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 (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
6891     pushExternalDeclIntoScope(PreloadedDecls[I],
6892                               PreloadedDecls[I]->getDeclName());
6893   }
6894   PreloadedDecls.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
7200 ASTReader::ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl *> &Decls) {
7201   for (unsigned I = 0, N = LocallyScopedExternCDecls.size(); I != N; ++I) {
7202     NamedDecl *D
7203       = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternCDecls[I]));
7204     if (D)
7205       Decls.push_back(D);
7206   }
7207   LocallyScopedExternCDecls.clear();
7208 }
7209
7210 void ASTReader::ReadReferencedSelectors(
7211        SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7212   if (ReferencedSelectorsData.empty())
7213     return;
7214
7215   // If there are @selector references added them to its pool. This is for
7216   // implementation of -Wselector.
7217   unsigned int DataSize = ReferencedSelectorsData.size()-1;
7218   unsigned I = 0;
7219   while (I < DataSize) {
7220     Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7221     SourceLocation SelLoc
7222       = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7223     Sels.push_back(std::make_pair(Sel, SelLoc));
7224   }
7225   ReferencedSelectorsData.clear();
7226 }
7227
7228 void ASTReader::ReadWeakUndeclaredIdentifiers(
7229        SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7230   if (WeakUndeclaredIdentifiers.empty())
7231     return;
7232
7233   for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7234     IdentifierInfo *WeakId
7235       = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7236     IdentifierInfo *AliasId
7237       = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7238     SourceLocation Loc
7239       = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7240     bool Used = WeakUndeclaredIdentifiers[I++];
7241     WeakInfo WI(AliasId, Loc);
7242     WI.setUsed(Used);
7243     WeakIDs.push_back(std::make_pair(WeakId, WI));
7244   }
7245   WeakUndeclaredIdentifiers.clear();
7246 }
7247
7248 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
7249   for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7250     ExternalVTableUse VT;
7251     VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7252     VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7253     VT.DefinitionRequired = VTableUses[Idx++];
7254     VTables.push_back(VT);
7255   }
7256
7257   VTableUses.clear();
7258 }
7259
7260 void ASTReader::ReadPendingInstantiations(
7261        SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
7262   for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
7263     ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
7264     SourceLocation Loc
7265       = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
7266
7267     Pending.push_back(std::make_pair(D, Loc));
7268   }
7269   PendingInstantiations.clear();
7270 }
7271
7272 void ASTReader::ReadLateParsedTemplates(
7273     llvm::DenseMap<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
7274   for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
7275        /* In loop */) {
7276     FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
7277
7278     LateParsedTemplate *LT = new LateParsedTemplate;
7279     LT->D = GetDecl(LateParsedTemplates[Idx++]);
7280
7281     ModuleFile *F = getOwningModuleFile(LT->D);
7282     assert(F && "No module");
7283
7284     unsigned TokN = LateParsedTemplates[Idx++];
7285     LT->Toks.reserve(TokN);
7286     for (unsigned T = 0; T < TokN; ++T)
7287       LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
7288
7289     LPTMap[FD] = LT;
7290   }
7291
7292   LateParsedTemplates.clear();
7293 }
7294
7295 void ASTReader::LoadSelector(Selector Sel) {
7296   // It would be complicated to avoid reading the methods anyway. So don't.
7297   ReadMethodPool(Sel);
7298 }
7299
7300 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
7301   assert(ID && "Non-zero identifier ID required");
7302   assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
7303   IdentifiersLoaded[ID - 1] = II;
7304   if (DeserializationListener)
7305     DeserializationListener->IdentifierRead(ID, II);
7306 }
7307
7308 /// \brief Set the globally-visible declarations associated with the given
7309 /// identifier.
7310 ///
7311 /// If the AST reader is currently in a state where the given declaration IDs
7312 /// cannot safely be resolved, they are queued until it is safe to resolve
7313 /// them.
7314 ///
7315 /// \param II an IdentifierInfo that refers to one or more globally-visible
7316 /// declarations.
7317 ///
7318 /// \param DeclIDs the set of declaration IDs with the name @p II that are
7319 /// visible at global scope.
7320 ///
7321 /// \param Decls if non-null, this vector will be populated with the set of
7322 /// deserialized declarations. These declarations will not be pushed into
7323 /// scope.
7324 void
7325 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
7326                               const SmallVectorImpl<uint32_t> &DeclIDs,
7327                                    SmallVectorImpl<Decl *> *Decls) {
7328   if (NumCurrentElementsDeserializing && !Decls) {
7329     PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
7330     return;
7331   }
7332
7333   for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
7334     NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
7335     if (SemaObj) {
7336       // If we're simply supposed to record the declarations, do so now.
7337       if (Decls) {
7338         Decls->push_back(D);
7339         continue;
7340       }
7341
7342       // Introduce this declaration into the translation-unit scope
7343       // and add it to the declaration chain for this identifier, so
7344       // that (unqualified) name lookup will find it.
7345       pushExternalDeclIntoScope(D, II);
7346     } else {
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       PreloadedDecls.push_back(D);
7351     }
7352   }
7353 }
7354
7355 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
7356   if (ID == 0)
7357     return nullptr;
7358
7359   if (IdentifiersLoaded.empty()) {
7360     Error("no identifier table in AST file");
7361     return nullptr;
7362   }
7363
7364   ID -= 1;
7365   if (!IdentifiersLoaded[ID]) {
7366     GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
7367     assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
7368     ModuleFile *M = I->second;
7369     unsigned Index = ID - M->BaseIdentifierID;
7370     const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
7371
7372     // All of the strings in the AST file are preceded by a 16-bit length.
7373     // Extract that 16-bit length to avoid having to execute strlen().
7374     // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
7375     //  unsigned integers.  This is important to avoid integer overflow when
7376     //  we cast them to 'unsigned'.
7377     const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
7378     unsigned StrLen = (((unsigned) StrLenPtr[0])
7379                        | (((unsigned) StrLenPtr[1]) << 8)) - 1;
7380     IdentifiersLoaded[ID]
7381       = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
7382     if (DeserializationListener)
7383       DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
7384   }
7385
7386   return IdentifiersLoaded[ID];
7387 }
7388
7389 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
7390   return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
7391 }
7392
7393 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
7394   if (LocalID < NUM_PREDEF_IDENT_IDS)
7395     return LocalID;
7396
7397   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7398     = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
7399   assert(I != M.IdentifierRemap.end()
7400          && "Invalid index into identifier index remap");
7401
7402   return LocalID + I->second;
7403 }
7404
7405 MacroInfo *ASTReader::getMacro(MacroID ID) {
7406   if (ID == 0)
7407     return nullptr;
7408
7409   if (MacrosLoaded.empty()) {
7410     Error("no macro table in AST file");
7411     return nullptr;
7412   }
7413
7414   ID -= NUM_PREDEF_MACRO_IDS;
7415   if (!MacrosLoaded[ID]) {
7416     GlobalMacroMapType::iterator I
7417       = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
7418     assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
7419     ModuleFile *M = I->second;
7420     unsigned Index = ID - M->BaseMacroID;
7421     MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
7422
7423     if (DeserializationListener)
7424       DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
7425                                          MacrosLoaded[ID]);
7426   }
7427
7428   return MacrosLoaded[ID];
7429 }
7430
7431 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
7432   if (LocalID < NUM_PREDEF_MACRO_IDS)
7433     return LocalID;
7434
7435   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7436     = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
7437   assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
7438
7439   return LocalID + I->second;
7440 }
7441
7442 serialization::SubmoduleID
7443 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
7444   if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
7445     return LocalID;
7446
7447   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7448     = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
7449   assert(I != M.SubmoduleRemap.end()
7450          && "Invalid index into submodule index remap");
7451
7452   return LocalID + I->second;
7453 }
7454
7455 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
7456   if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
7457     assert(GlobalID == 0 && "Unhandled global submodule ID");
7458     return nullptr;
7459   }
7460
7461   if (GlobalID > SubmodulesLoaded.size()) {
7462     Error("submodule ID out of range in AST file");
7463     return nullptr;
7464   }
7465
7466   return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
7467 }
7468
7469 Module *ASTReader::getModule(unsigned ID) {
7470   return getSubmodule(ID);
7471 }
7472
7473 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
7474   return DecodeSelector(getGlobalSelectorID(M, LocalID));
7475 }
7476
7477 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
7478   if (ID == 0)
7479     return Selector();
7480
7481   if (ID > SelectorsLoaded.size()) {
7482     Error("selector ID out of range in AST file");
7483     return Selector();
7484   }
7485
7486   if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
7487     // Load this selector from the selector table.
7488     GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
7489     assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
7490     ModuleFile &M = *I->second;
7491     ASTSelectorLookupTrait Trait(*this, M);
7492     unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
7493     SelectorsLoaded[ID - 1] =
7494       Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
7495     if (DeserializationListener)
7496       DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
7497   }
7498
7499   return SelectorsLoaded[ID - 1];
7500 }
7501
7502 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
7503   return DecodeSelector(ID);
7504 }
7505
7506 uint32_t ASTReader::GetNumExternalSelectors() {
7507   // ID 0 (the null selector) is considered an external selector.
7508   return getTotalNumSelectors() + 1;
7509 }
7510
7511 serialization::SelectorID
7512 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
7513   if (LocalID < NUM_PREDEF_SELECTOR_IDS)
7514     return LocalID;
7515
7516   ContinuousRangeMap<uint32_t, int, 2>::iterator I
7517     = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
7518   assert(I != M.SelectorRemap.end()
7519          && "Invalid index into selector index remap");
7520
7521   return LocalID + I->second;
7522 }
7523
7524 DeclarationName
7525 ASTReader::ReadDeclarationName(ModuleFile &F,
7526                                const RecordData &Record, unsigned &Idx) {
7527   DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
7528   switch (Kind) {
7529   case DeclarationName::Identifier:
7530     return DeclarationName(GetIdentifierInfo(F, Record, Idx));
7531
7532   case DeclarationName::ObjCZeroArgSelector:
7533   case DeclarationName::ObjCOneArgSelector:
7534   case DeclarationName::ObjCMultiArgSelector:
7535     return DeclarationName(ReadSelector(F, Record, Idx));
7536
7537   case DeclarationName::CXXConstructorName:
7538     return Context.DeclarationNames.getCXXConstructorName(
7539                           Context.getCanonicalType(readType(F, Record, Idx)));
7540
7541   case DeclarationName::CXXDestructorName:
7542     return Context.DeclarationNames.getCXXDestructorName(
7543                           Context.getCanonicalType(readType(F, Record, Idx)));
7544
7545   case DeclarationName::CXXConversionFunctionName:
7546     return Context.DeclarationNames.getCXXConversionFunctionName(
7547                           Context.getCanonicalType(readType(F, Record, Idx)));
7548
7549   case DeclarationName::CXXOperatorName:
7550     return Context.DeclarationNames.getCXXOperatorName(
7551                                        (OverloadedOperatorKind)Record[Idx++]);
7552
7553   case DeclarationName::CXXLiteralOperatorName:
7554     return Context.DeclarationNames.getCXXLiteralOperatorName(
7555                                        GetIdentifierInfo(F, Record, Idx));
7556
7557   case DeclarationName::CXXUsingDirective:
7558     return DeclarationName::getUsingDirectiveName();
7559   }
7560
7561   llvm_unreachable("Invalid NameKind!");
7562 }
7563
7564 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
7565                                        DeclarationNameLoc &DNLoc,
7566                                        DeclarationName Name,
7567                                       const RecordData &Record, unsigned &Idx) {
7568   switch (Name.getNameKind()) {
7569   case DeclarationName::CXXConstructorName:
7570   case DeclarationName::CXXDestructorName:
7571   case DeclarationName::CXXConversionFunctionName:
7572     DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
7573     break;
7574
7575   case DeclarationName::CXXOperatorName:
7576     DNLoc.CXXOperatorName.BeginOpNameLoc
7577         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7578     DNLoc.CXXOperatorName.EndOpNameLoc
7579         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7580     break;
7581
7582   case DeclarationName::CXXLiteralOperatorName:
7583     DNLoc.CXXLiteralOperatorName.OpNameLoc
7584         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7585     break;
7586
7587   case DeclarationName::Identifier:
7588   case DeclarationName::ObjCZeroArgSelector:
7589   case DeclarationName::ObjCOneArgSelector:
7590   case DeclarationName::ObjCMultiArgSelector:
7591   case DeclarationName::CXXUsingDirective:
7592     break;
7593   }
7594 }
7595
7596 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
7597                                         DeclarationNameInfo &NameInfo,
7598                                       const RecordData &Record, unsigned &Idx) {
7599   NameInfo.setName(ReadDeclarationName(F, Record, Idx));
7600   NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
7601   DeclarationNameLoc DNLoc;
7602   ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
7603   NameInfo.setInfo(DNLoc);
7604 }
7605
7606 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
7607                                   const RecordData &Record, unsigned &Idx) {
7608   Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
7609   unsigned NumTPLists = Record[Idx++];
7610   Info.NumTemplParamLists = NumTPLists;
7611   if (NumTPLists) {
7612     Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
7613     for (unsigned i=0; i != NumTPLists; ++i)
7614       Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
7615   }
7616 }
7617
7618 TemplateName
7619 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
7620                             unsigned &Idx) {
7621   TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
7622   switch (Kind) {
7623   case TemplateName::Template:
7624       return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
7625
7626   case TemplateName::OverloadedTemplate: {
7627     unsigned size = Record[Idx++];
7628     UnresolvedSet<8> Decls;
7629     while (size--)
7630       Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
7631
7632     return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
7633   }
7634
7635   case TemplateName::QualifiedTemplate: {
7636     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7637     bool hasTemplKeyword = Record[Idx++];
7638     TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
7639     return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
7640   }
7641
7642   case TemplateName::DependentTemplate: {
7643     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7644     if (Record[Idx++])  // isIdentifier
7645       return Context.getDependentTemplateName(NNS,
7646                                                GetIdentifierInfo(F, Record,
7647                                                                  Idx));
7648     return Context.getDependentTemplateName(NNS,
7649                                          (OverloadedOperatorKind)Record[Idx++]);
7650   }
7651
7652   case TemplateName::SubstTemplateTemplateParm: {
7653     TemplateTemplateParmDecl *param
7654       = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7655     if (!param) return TemplateName();
7656     TemplateName replacement = ReadTemplateName(F, Record, Idx);
7657     return Context.getSubstTemplateTemplateParm(param, replacement);
7658   }
7659
7660   case TemplateName::SubstTemplateTemplateParmPack: {
7661     TemplateTemplateParmDecl *Param
7662       = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7663     if (!Param)
7664       return TemplateName();
7665
7666     TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
7667     if (ArgPack.getKind() != TemplateArgument::Pack)
7668       return TemplateName();
7669
7670     return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
7671   }
7672   }
7673
7674   llvm_unreachable("Unhandled template name kind!");
7675 }
7676
7677 TemplateArgument
7678 ASTReader::ReadTemplateArgument(ModuleFile &F,
7679                                 const RecordData &Record, unsigned &Idx) {
7680   TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
7681   switch (Kind) {
7682   case TemplateArgument::Null:
7683     return TemplateArgument();
7684   case TemplateArgument::Type:
7685     return TemplateArgument(readType(F, Record, Idx));
7686   case TemplateArgument::Declaration: {
7687     ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
7688     bool ForReferenceParam = Record[Idx++];
7689     return TemplateArgument(D, ForReferenceParam);
7690   }
7691   case TemplateArgument::NullPtr:
7692     return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
7693   case TemplateArgument::Integral: {
7694     llvm::APSInt Value = ReadAPSInt(Record, Idx);
7695     QualType T = readType(F, Record, Idx);
7696     return TemplateArgument(Context, Value, T);
7697   }
7698   case TemplateArgument::Template:
7699     return TemplateArgument(ReadTemplateName(F, Record, Idx));
7700   case TemplateArgument::TemplateExpansion: {
7701     TemplateName Name = ReadTemplateName(F, Record, Idx);
7702     Optional<unsigned> NumTemplateExpansions;
7703     if (unsigned NumExpansions = Record[Idx++])
7704       NumTemplateExpansions = NumExpansions - 1;
7705     return TemplateArgument(Name, NumTemplateExpansions);
7706   }
7707   case TemplateArgument::Expression:
7708     return TemplateArgument(ReadExpr(F));
7709   case TemplateArgument::Pack: {
7710     unsigned NumArgs = Record[Idx++];
7711     TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
7712     for (unsigned I = 0; I != NumArgs; ++I)
7713       Args[I] = ReadTemplateArgument(F, Record, Idx);
7714     return TemplateArgument(Args, NumArgs);
7715   }
7716   }
7717
7718   llvm_unreachable("Unhandled template argument kind!");
7719 }
7720
7721 TemplateParameterList *
7722 ASTReader::ReadTemplateParameterList(ModuleFile &F,
7723                                      const RecordData &Record, unsigned &Idx) {
7724   SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
7725   SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
7726   SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
7727
7728   unsigned NumParams = Record[Idx++];
7729   SmallVector<NamedDecl *, 16> Params;
7730   Params.reserve(NumParams);
7731   while (NumParams--)
7732     Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
7733
7734   TemplateParameterList* TemplateParams =
7735     TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
7736                                   Params.data(), Params.size(), RAngleLoc);
7737   return TemplateParams;
7738 }
7739
7740 void
7741 ASTReader::
7742 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
7743                          ModuleFile &F, const RecordData &Record,
7744                          unsigned &Idx) {
7745   unsigned NumTemplateArgs = Record[Idx++];
7746   TemplArgs.reserve(NumTemplateArgs);
7747   while (NumTemplateArgs--)
7748     TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
7749 }
7750
7751 /// \brief Read a UnresolvedSet structure.
7752 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
7753                                   const RecordData &Record, unsigned &Idx) {
7754   unsigned NumDecls = Record[Idx++];
7755   Set.reserve(Context, NumDecls);
7756   while (NumDecls--) {
7757     DeclID ID = ReadDeclID(F, Record, Idx);
7758     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
7759     Set.addLazyDecl(Context, ID, AS);
7760   }
7761 }
7762
7763 CXXBaseSpecifier
7764 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
7765                                 const RecordData &Record, unsigned &Idx) {
7766   bool isVirtual = static_cast<bool>(Record[Idx++]);
7767   bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
7768   AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
7769   bool inheritConstructors = static_cast<bool>(Record[Idx++]);
7770   TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
7771   SourceRange Range = ReadSourceRange(F, Record, Idx);
7772   SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
7773   CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
7774                           EllipsisLoc);
7775   Result.setInheritConstructors(inheritConstructors);
7776   return Result;
7777 }
7778
7779 std::pair<CXXCtorInitializer **, unsigned>
7780 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
7781                                    unsigned &Idx) {
7782   CXXCtorInitializer **CtorInitializers = nullptr;
7783   unsigned NumInitializers = Record[Idx++];
7784   if (NumInitializers) {
7785     CtorInitializers
7786         = new (Context) CXXCtorInitializer*[NumInitializers];
7787     for (unsigned i=0; i != NumInitializers; ++i) {
7788       TypeSourceInfo *TInfo = nullptr;
7789       bool IsBaseVirtual = false;
7790       FieldDecl *Member = nullptr;
7791       IndirectFieldDecl *IndirectMember = nullptr;
7792
7793       CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
7794       switch (Type) {
7795       case CTOR_INITIALIZER_BASE:
7796         TInfo = GetTypeSourceInfo(F, Record, Idx);
7797         IsBaseVirtual = Record[Idx++];
7798         break;
7799
7800       case CTOR_INITIALIZER_DELEGATING:
7801         TInfo = GetTypeSourceInfo(F, Record, Idx);
7802         break;
7803
7804        case CTOR_INITIALIZER_MEMBER:
7805         Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
7806         break;
7807
7808        case CTOR_INITIALIZER_INDIRECT_MEMBER:
7809         IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
7810         break;
7811       }
7812
7813       SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
7814       Expr *Init = ReadExpr(F);
7815       SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
7816       SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
7817       bool IsWritten = Record[Idx++];
7818       unsigned SourceOrderOrNumArrayIndices;
7819       SmallVector<VarDecl *, 8> Indices;
7820       if (IsWritten) {
7821         SourceOrderOrNumArrayIndices = Record[Idx++];
7822       } else {
7823         SourceOrderOrNumArrayIndices = Record[Idx++];
7824         Indices.reserve(SourceOrderOrNumArrayIndices);
7825         for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
7826           Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
7827       }
7828
7829       CXXCtorInitializer *BOMInit;
7830       if (Type == CTOR_INITIALIZER_BASE) {
7831         BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual,
7832                                              LParenLoc, Init, RParenLoc,
7833                                              MemberOrEllipsisLoc);
7834       } else if (Type == CTOR_INITIALIZER_DELEGATING) {
7835         BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc,
7836                                                    Init, RParenLoc);
7837       } else if (IsWritten) {
7838         if (Member)
7839           BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
7840                                                LParenLoc, Init, RParenLoc);
7841         else
7842           BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
7843                                                MemberOrEllipsisLoc, LParenLoc,
7844                                                Init, RParenLoc);
7845       } else {
7846         if (IndirectMember) {
7847           assert(Indices.empty() && "Indirect field improperly initialized");
7848           BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
7849                                                      MemberOrEllipsisLoc, LParenLoc,
7850                                                      Init, RParenLoc);
7851         } else {
7852           BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc,
7853                                                LParenLoc, Init, RParenLoc,
7854                                                Indices.data(), Indices.size());
7855         }
7856       }
7857
7858       if (IsWritten)
7859         BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
7860       CtorInitializers[i] = BOMInit;
7861     }
7862   }
7863
7864   return std::make_pair(CtorInitializers, NumInitializers);
7865 }
7866
7867 NestedNameSpecifier *
7868 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
7869                                    const RecordData &Record, unsigned &Idx) {
7870   unsigned N = Record[Idx++];
7871   NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
7872   for (unsigned I = 0; I != N; ++I) {
7873     NestedNameSpecifier::SpecifierKind Kind
7874       = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
7875     switch (Kind) {
7876     case NestedNameSpecifier::Identifier: {
7877       IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
7878       NNS = NestedNameSpecifier::Create(Context, Prev, II);
7879       break;
7880     }
7881
7882     case NestedNameSpecifier::Namespace: {
7883       NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
7884       NNS = NestedNameSpecifier::Create(Context, Prev, NS);
7885       break;
7886     }
7887
7888     case NestedNameSpecifier::NamespaceAlias: {
7889       NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
7890       NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
7891       break;
7892     }
7893
7894     case NestedNameSpecifier::TypeSpec:
7895     case NestedNameSpecifier::TypeSpecWithTemplate: {
7896       const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
7897       if (!T)
7898         return nullptr;
7899
7900       bool Template = Record[Idx++];
7901       NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
7902       break;
7903     }
7904
7905     case NestedNameSpecifier::Global: {
7906       NNS = NestedNameSpecifier::GlobalSpecifier(Context);
7907       // No associated value, and there can't be a prefix.
7908       break;
7909     }
7910     }
7911     Prev = NNS;
7912   }
7913   return NNS;
7914 }
7915
7916 NestedNameSpecifierLoc
7917 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
7918                                       unsigned &Idx) {
7919   unsigned N = Record[Idx++];
7920   NestedNameSpecifierLocBuilder Builder;
7921   for (unsigned I = 0; I != N; ++I) {
7922     NestedNameSpecifier::SpecifierKind Kind
7923       = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
7924     switch (Kind) {
7925     case NestedNameSpecifier::Identifier: {
7926       IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
7927       SourceRange Range = ReadSourceRange(F, Record, Idx);
7928       Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
7929       break;
7930     }
7931
7932     case NestedNameSpecifier::Namespace: {
7933       NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
7934       SourceRange Range = ReadSourceRange(F, Record, Idx);
7935       Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
7936       break;
7937     }
7938
7939     case NestedNameSpecifier::NamespaceAlias: {
7940       NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
7941       SourceRange Range = ReadSourceRange(F, Record, Idx);
7942       Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
7943       break;
7944     }
7945
7946     case NestedNameSpecifier::TypeSpec:
7947     case NestedNameSpecifier::TypeSpecWithTemplate: {
7948       bool Template = Record[Idx++];
7949       TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
7950       if (!T)
7951         return NestedNameSpecifierLoc();
7952       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
7953
7954       // FIXME: 'template' keyword location not saved anywhere, so we fake it.
7955       Builder.Extend(Context,
7956                      Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
7957                      T->getTypeLoc(), ColonColonLoc);
7958       break;
7959     }
7960
7961     case NestedNameSpecifier::Global: {
7962       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
7963       Builder.MakeGlobal(Context, ColonColonLoc);
7964       break;
7965     }
7966     }
7967   }
7968
7969   return Builder.getWithLocInContext(Context);
7970 }
7971
7972 SourceRange
7973 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
7974                            unsigned &Idx) {
7975   SourceLocation beg = ReadSourceLocation(F, Record, Idx);
7976   SourceLocation end = ReadSourceLocation(F, Record, Idx);
7977   return SourceRange(beg, end);
7978 }
7979
7980 /// \brief Read an integral value
7981 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
7982   unsigned BitWidth = Record[Idx++];
7983   unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
7984   llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
7985   Idx += NumWords;
7986   return Result;
7987 }
7988
7989 /// \brief Read a signed integral value
7990 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
7991   bool isUnsigned = Record[Idx++];
7992   return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
7993 }
7994
7995 /// \brief Read a floating-point value
7996 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
7997                                      const llvm::fltSemantics &Sem,
7998                                      unsigned &Idx) {
7999   return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8000 }
8001
8002 // \brief Read a string
8003 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8004   unsigned Len = Record[Idx++];
8005   std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8006   Idx += Len;
8007   return Result;
8008 }
8009
8010 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
8011                                          unsigned &Idx) {
8012   unsigned Major = Record[Idx++];
8013   unsigned Minor = Record[Idx++];
8014   unsigned Subminor = Record[Idx++];
8015   if (Minor == 0)
8016     return VersionTuple(Major);
8017   if (Subminor == 0)
8018     return VersionTuple(Major, Minor - 1);
8019   return VersionTuple(Major, Minor - 1, Subminor - 1);
8020 }
8021
8022 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
8023                                           const RecordData &Record,
8024                                           unsigned &Idx) {
8025   CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8026   return CXXTemporary::Create(Context, Decl);
8027 }
8028
8029 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
8030   return Diag(CurrentImportLoc, DiagID);
8031 }
8032
8033 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
8034   return Diags.Report(Loc, DiagID);
8035 }
8036
8037 /// \brief Retrieve the identifier table associated with the
8038 /// preprocessor.
8039 IdentifierTable &ASTReader::getIdentifierTable() {
8040   return PP.getIdentifierTable();
8041 }
8042
8043 /// \brief Record that the given ID maps to the given switch-case
8044 /// statement.
8045 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
8046   assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8047          "Already have a SwitchCase with this ID");
8048   (*CurrSwitchCaseStmts)[ID] = SC;
8049 }
8050
8051 /// \brief Retrieve the switch-case statement with the given ID.
8052 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
8053   assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8054   return (*CurrSwitchCaseStmts)[ID];
8055 }
8056
8057 void ASTReader::ClearSwitchCaseIDs() {
8058   CurrSwitchCaseStmts->clear();
8059 }
8060
8061 void ASTReader::ReadComments() {
8062   std::vector<RawComment *> Comments;
8063   for (SmallVectorImpl<std::pair<BitstreamCursor,
8064                                  serialization::ModuleFile *> >::iterator
8065        I = CommentsCursors.begin(),
8066        E = CommentsCursors.end();
8067        I != E; ++I) {
8068     Comments.clear();
8069     BitstreamCursor &Cursor = I->first;
8070     serialization::ModuleFile &F = *I->second;
8071     SavedStreamPosition SavedPosition(Cursor);
8072
8073     RecordData Record;
8074     while (true) {
8075       llvm::BitstreamEntry Entry =
8076         Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
8077
8078       switch (Entry.Kind) {
8079       case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8080       case llvm::BitstreamEntry::Error:
8081         Error("malformed block record in AST file");
8082         return;
8083       case llvm::BitstreamEntry::EndBlock:
8084         goto NextCursor;
8085       case llvm::BitstreamEntry::Record:
8086         // The interesting case.
8087         break;
8088       }
8089
8090       // Read a record.
8091       Record.clear();
8092       switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
8093       case COMMENTS_RAW_COMMENT: {
8094         unsigned Idx = 0;
8095         SourceRange SR = ReadSourceRange(F, Record, Idx);
8096         RawComment::CommentKind Kind =
8097             (RawComment::CommentKind) Record[Idx++];
8098         bool IsTrailingComment = Record[Idx++];
8099         bool IsAlmostTrailingComment = Record[Idx++];
8100         Comments.push_back(new (Context) RawComment(
8101             SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8102             Context.getLangOpts().CommentOpts.ParseAllComments));
8103         break;
8104       }
8105       }
8106     }
8107   NextCursor:
8108     Context.Comments.addDeserializedComments(Comments);
8109   }
8110 }
8111
8112 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
8113   // If we know the owning module, use it.
8114   if (Module *M = D->getOwningModule())
8115     return M->getFullModuleName();
8116
8117   // Otherwise, use the name of the top-level module the decl is within.
8118   if (ModuleFile *M = getOwningModuleFile(D))
8119     return M->ModuleName;
8120
8121   // Not from a module.
8122   return "";
8123 }
8124
8125 void ASTReader::finishPendingActions() {
8126   while (!PendingIdentifierInfos.empty() ||
8127          !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
8128          !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
8129          !PendingUpdateRecords.empty()) {
8130     // If any identifiers with corresponding top-level declarations have
8131     // been loaded, load those declarations now.
8132     typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8133       TopLevelDeclsMap;
8134     TopLevelDeclsMap TopLevelDecls;
8135
8136     while (!PendingIdentifierInfos.empty()) {
8137       IdentifierInfo *II = PendingIdentifierInfos.back().first;
8138       SmallVector<uint32_t, 4> DeclIDs =
8139           std::move(PendingIdentifierInfos.back().second);
8140       PendingIdentifierInfos.pop_back();
8141
8142       SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
8143     }
8144
8145     // For each decl chain that we wanted to complete while deserializing, mark
8146     // it as "still needs to be completed".
8147     for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
8148       markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
8149     }
8150     PendingIncompleteDeclChains.clear();
8151
8152     // Load pending declaration chains.
8153     for (unsigned I = 0; I != PendingDeclChains.size(); ++I) {
8154       loadPendingDeclChain(PendingDeclChains[I]);
8155       PendingDeclChainsKnown.erase(PendingDeclChains[I]);
8156     }
8157     PendingDeclChains.clear();
8158
8159     // Make the most recent of the top-level declarations visible.
8160     for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
8161            TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
8162       IdentifierInfo *II = TLD->first;
8163       for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
8164         pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
8165       }
8166     }
8167
8168     // Load any pending macro definitions.
8169     for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
8170       IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
8171       SmallVector<PendingMacroInfo, 2> GlobalIDs;
8172       GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
8173       // Initialize the macro history from chained-PCHs ahead of module imports.
8174       for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8175            ++IDIdx) {
8176         const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8177         if (Info.M->Kind != MK_Module)
8178           resolvePendingMacro(II, Info);
8179       }
8180       // Handle module imports.
8181       for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8182            ++IDIdx) {
8183         const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8184         if (Info.M->Kind == MK_Module)
8185           resolvePendingMacro(II, Info);
8186       }
8187     }
8188     PendingMacroIDs.clear();
8189
8190     // Wire up the DeclContexts for Decls that we delayed setting until
8191     // recursive loading is completed.
8192     while (!PendingDeclContextInfos.empty()) {
8193       PendingDeclContextInfo Info = PendingDeclContextInfos.front();
8194       PendingDeclContextInfos.pop_front();
8195       DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
8196       DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
8197       Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
8198     }
8199
8200     // Perform any pending declaration updates.
8201     while (!PendingUpdateRecords.empty()) {
8202       auto Update = PendingUpdateRecords.pop_back_val();
8203       ReadingKindTracker ReadingKind(Read_Decl, *this);
8204       loadDeclUpdateRecords(Update.first, Update.second);
8205     }
8206   }
8207
8208   // If we deserialized any C++ or Objective-C class definitions, any
8209   // Objective-C protocol definitions, or any redeclarable templates, make sure
8210   // that all redeclarations point to the definitions. Note that this can only
8211   // happen now, after the redeclaration chains have been fully wired.
8212   for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(),
8213                                            DEnd = PendingDefinitions.end();
8214        D != DEnd; ++D) {
8215     if (TagDecl *TD = dyn_cast<TagDecl>(*D)) {
8216       if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
8217         // Make sure that the TagType points at the definition.
8218         const_cast<TagType*>(TagT)->decl = TD;
8219       }
8220
8221       if (auto RD = dyn_cast<CXXRecordDecl>(*D)) {
8222         for (auto R : RD->redecls())
8223           cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
8224       }
8225
8226       continue;
8227     }
8228
8229     if (auto ID = dyn_cast<ObjCInterfaceDecl>(*D)) {
8230       // Make sure that the ObjCInterfaceType points at the definition.
8231       const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
8232         ->Decl = ID;
8233
8234       for (auto R : ID->redecls())
8235         R->Data = ID->Data;
8236
8237       continue;
8238     }
8239
8240     if (auto PD = dyn_cast<ObjCProtocolDecl>(*D)) {
8241       for (auto R : PD->redecls())
8242         R->Data = PD->Data;
8243
8244       continue;
8245     }
8246
8247     auto RTD = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl();
8248     for (auto R : RTD->redecls())
8249       R->Common = RTD->Common;
8250   }
8251   PendingDefinitions.clear();
8252
8253   // Load the bodies of any functions or methods we've encountered. We do
8254   // this now (delayed) so that we can be sure that the declaration chains
8255   // have been fully wired up.
8256   for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
8257                                PBEnd = PendingBodies.end();
8258        PB != PBEnd; ++PB) {
8259     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
8260       // FIXME: Check for =delete/=default?
8261       // FIXME: Complain about ODR violations here?
8262       if (!getContext().getLangOpts().Modules || !FD->hasBody())
8263         FD->setLazyBody(PB->second);
8264       continue;
8265     }
8266
8267     ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
8268     if (!getContext().getLangOpts().Modules || !MD->hasBody())
8269       MD->setLazyBody(PB->second);
8270   }
8271   PendingBodies.clear();
8272 }
8273
8274 void ASTReader::diagnoseOdrViolations() {
8275   if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
8276     return;
8277
8278   // Trigger the import of the full definition of each class that had any
8279   // odr-merging problems, so we can produce better diagnostics for them.
8280   // These updates may in turn find and diagnose some ODR failures, so take
8281   // ownership of the set first.
8282   auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
8283   PendingOdrMergeFailures.clear();
8284   for (auto &Merge : OdrMergeFailures) {
8285     Merge.first->buildLookup();
8286     Merge.first->decls_begin();
8287     Merge.first->bases_begin();
8288     Merge.first->vbases_begin();
8289     for (auto *RD : Merge.second) {
8290       RD->decls_begin();
8291       RD->bases_begin();
8292       RD->vbases_begin();
8293     }
8294   }
8295
8296   // For each declaration from a merged context, check that the canonical
8297   // definition of that context also contains a declaration of the same
8298   // entity.
8299   //
8300   // Caution: this loop does things that might invalidate iterators into
8301   // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
8302   while (!PendingOdrMergeChecks.empty()) {
8303     NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
8304
8305     // FIXME: Skip over implicit declarations for now. This matters for things
8306     // like implicitly-declared special member functions. This isn't entirely
8307     // correct; we can end up with multiple unmerged declarations of the same
8308     // implicit entity.
8309     if (D->isImplicit())
8310       continue;
8311
8312     DeclContext *CanonDef = D->getDeclContext();
8313     DeclContext::lookup_result R = CanonDef->lookup(D->getDeclName());
8314
8315     bool Found = false;
8316     const Decl *DCanon = D->getCanonicalDecl();
8317
8318     llvm::SmallVector<const NamedDecl*, 4> Candidates;
8319     for (DeclContext::lookup_iterator I = R.begin(), E = R.end();
8320          !Found && I != E; ++I) {
8321       for (auto RI : (*I)->redecls()) {
8322         if (RI->getLexicalDeclContext() == CanonDef) {
8323           // This declaration is present in the canonical definition. If it's
8324           // in the same redecl chain, it's the one we're looking for.
8325           if (RI->getCanonicalDecl() == DCanon)
8326             Found = true;
8327           else
8328             Candidates.push_back(cast<NamedDecl>(RI));
8329           break;
8330         }
8331       }
8332     }
8333
8334     if (!Found) {
8335       D->setInvalidDecl();
8336
8337       std::string CanonDefModule =
8338           getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
8339       Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
8340         << D << getOwningModuleNameForDiagnostic(D)
8341         << CanonDef << CanonDefModule.empty() << CanonDefModule;
8342
8343       if (Candidates.empty())
8344         Diag(cast<Decl>(CanonDef)->getLocation(),
8345              diag::note_module_odr_violation_no_possible_decls) << D;
8346       else {
8347         for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
8348           Diag(Candidates[I]->getLocation(),
8349                diag::note_module_odr_violation_possible_decl)
8350             << Candidates[I];
8351       }
8352
8353       DiagnosedOdrMergeFailures.insert(CanonDef);
8354     }
8355   }
8356
8357   // Issue any pending ODR-failure diagnostics.
8358   for (auto &Merge : OdrMergeFailures) {
8359     // If we've already pointed out a specific problem with this class, don't
8360     // bother issuing a general "something's different" diagnostic.
8361     if (!DiagnosedOdrMergeFailures.insert(Merge.first))
8362       continue;
8363
8364     bool Diagnosed = false;
8365     for (auto *RD : Merge.second) {
8366       // Multiple different declarations got merged together; tell the user
8367       // where they came from.
8368       if (Merge.first != RD) {
8369         // FIXME: Walk the definition, figure out what's different,
8370         // and diagnose that.
8371         if (!Diagnosed) {
8372           std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
8373           Diag(Merge.first->getLocation(),
8374                diag::err_module_odr_violation_different_definitions)
8375             << Merge.first << Module.empty() << Module;
8376           Diagnosed = true;
8377         }
8378
8379         Diag(RD->getLocation(),
8380              diag::note_module_odr_violation_different_definitions)
8381           << getOwningModuleNameForDiagnostic(RD);
8382       }
8383     }
8384
8385     if (!Diagnosed) {
8386       // All definitions are updates to the same declaration. This happens if a
8387       // module instantiates the declaration of a class template specialization
8388       // and two or more other modules instantiate its definition.
8389       //
8390       // FIXME: Indicate which modules had instantiations of this definition.
8391       // FIXME: How can this even happen?
8392       Diag(Merge.first->getLocation(),
8393            diag::err_module_odr_violation_different_instantiations)
8394         << Merge.first;
8395     }
8396   }
8397 }
8398
8399 void ASTReader::FinishedDeserializing() {
8400   assert(NumCurrentElementsDeserializing &&
8401          "FinishedDeserializing not paired with StartedDeserializing");
8402   if (NumCurrentElementsDeserializing == 1) {
8403     // We decrease NumCurrentElementsDeserializing only after pending actions
8404     // are finished, to avoid recursively re-calling finishPendingActions().
8405     finishPendingActions();
8406   }
8407   --NumCurrentElementsDeserializing;
8408
8409   if (NumCurrentElementsDeserializing == 0) {
8410     diagnoseOdrViolations();
8411
8412     // We are not in recursive loading, so it's safe to pass the "interesting"
8413     // decls to the consumer.
8414     if (Consumer)
8415       PassInterestingDeclsToConsumer();
8416   }
8417 }
8418
8419 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
8420   D = D->getMostRecentDecl();
8421
8422   if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
8423     SemaObj->TUScope->AddDecl(D);
8424   } else if (SemaObj->TUScope) {
8425     // Adding the decl to IdResolver may have failed because it was already in
8426     // (even though it was not added in scope). If it is already in, make sure
8427     // it gets in the scope as well.
8428     if (std::find(SemaObj->IdResolver.begin(Name),
8429                   SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
8430       SemaObj->TUScope->AddDecl(D);
8431   }
8432 }
8433
8434 ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, StringRef isysroot,
8435                      bool DisableValidation, bool AllowASTWithCompilerErrors,
8436                      bool AllowConfigurationMismatch, bool ValidateSystemInputs,
8437                      bool UseGlobalIndex)
8438     : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr),
8439       OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
8440       FileMgr(PP.getFileManager()), Diags(PP.getDiagnostics()),
8441       SemaObj(nullptr), PP(PP), Context(Context), Consumer(nullptr),
8442       ModuleMgr(PP.getFileManager()), isysroot(isysroot),
8443       DisableValidation(DisableValidation),
8444       AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
8445       AllowConfigurationMismatch(AllowConfigurationMismatch),
8446       ValidateSystemInputs(ValidateSystemInputs),
8447       UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
8448       CurrSwitchCaseStmts(&SwitchCaseStmts),
8449       NumSLocEntriesRead(0), TotalNumSLocEntries(0), NumStatementsRead(0),
8450       TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
8451       NumIdentifierLookups(0), NumIdentifierLookupHits(0), NumSelectorsRead(0),
8452       NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
8453       NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
8454       NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
8455       NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
8456       NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
8457       TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
8458       PassingDeclsToConsumer(false), NumCXXBaseSpecifiersLoaded(0),
8459       ReadingKind(Read_None) {
8460   SourceMgr.setExternalSLocEntrySource(this);
8461 }
8462
8463 ASTReader::~ASTReader() {
8464   if (OwnsDeserializationListener)
8465     delete DeserializationListener;
8466
8467   for (DeclContextVisibleUpdatesPending::iterator
8468            I = PendingVisibleUpdates.begin(),
8469            E = PendingVisibleUpdates.end();
8470        I != E; ++I) {
8471     for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
8472                                              F = I->second.end();
8473          J != F; ++J)
8474       delete J->first;
8475   }
8476 }