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

   1 //===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===//
   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 "clang/Serialization/ASTDeserializationListener.h"
  16 #include "ASTCommon.h"
  17 #include "clang/Frontend/FrontendDiagnostic.h"
  18 #include "clang/Frontend/Utils.h"
  19 #include "clang/Sema/Sema.h"
  20 #include "clang/Sema/Scope.h"
  21 #include "clang/AST/ASTConsumer.h"
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/DeclTemplate.h"
  24 #include "clang/AST/Expr.h"
  25 #include "clang/AST/ExprCXX.h"
  26 #include "clang/AST/NestedNameSpecifier.h"
  27 #include "clang/AST/Type.h"
  28 #include "clang/AST/TypeLocVisitor.h"
  29 #include "clang/Lex/MacroInfo.h"
  30 #include "clang/Lex/PreprocessingRecord.h"
  31 #include "clang/Lex/Preprocessor.h"
  32 #include "clang/Lex/HeaderSearch.h"
  33 #include "clang/Basic/OnDiskHashTable.h"
  34 #include "clang/Basic/SourceManager.h"
  35 #include "clang/Basic/SourceManagerInternals.h"
  36 #include "clang/Basic/FileManager.h"
  37 #include "clang/Basic/FileSystemStatCache.h"
  38 #include "clang/Basic/TargetInfo.h"
  39 #include "clang/Basic/Version.h"
  40 #include "clang/Basic/VersionTuple.h"
  41 #include "llvm/ADT/StringExtras.h"
  42 #include "llvm/Bitcode/BitstreamReader.h"
  43 #include "llvm/Support/MemoryBuffer.h"
  44 #include "llvm/Support/ErrorHandling.h"
  45 #include "llvm/Support/FileSystem.h"
  46 #include "llvm/Support/Path.h"
  47 #include "llvm/Support/system_error.h"
  48 #include <algorithm>
  49 #include <iterator>
  50 #include <cstdio>
  51 #include <sys/stat.h>
  52
  53 using namespace clang;
  54 using namespace clang::serialization;
  55
  56 //===----------------------------------------------------------------------===//
  57 // PCH validator implementation
  58 //===----------------------------------------------------------------------===//
  59
  60 ASTReaderListener::~ASTReaderListener() {}
  61
  62 bool
  63 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
  64   const LangOptions &PPLangOpts = PP.getLangOptions();
  65 #define PARSE_LANGOPT_BENIGN(Option)
  66 #define PARSE_LANGOPT_IMPORTANT(Option, DiagID)                    \
  67   if (PPLangOpts.Option != LangOpts.Option) {                      \
  68     Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option;   \
  69     return true;                                                   \
  70   }
  71
  72   PARSE_LANGOPT_BENIGN(Trigraphs);
  73   PARSE_LANGOPT_BENIGN(BCPLComment);
  74   PARSE_LANGOPT_BENIGN(DollarIdents);
  75   PARSE_LANGOPT_BENIGN(AsmPreprocessor);
  76   PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions);
  77   PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords);
  78   PARSE_LANGOPT_BENIGN(ImplicitInt);
  79   PARSE_LANGOPT_BENIGN(Digraphs);
  80   PARSE_LANGOPT_BENIGN(HexFloats);
  81   PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99);
  82   PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x);
  83   PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions);
  84   PARSE_LANGOPT_BENIGN(MSCVersion);
  85   PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
  86   PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
  87   PARSE_LANGOPT_BENIGN(CXXOperatorName);
  88   PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c);
  89   PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2);
  90   PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi);
  91   PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2);
  92   PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext);
  93   PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties,
  94                           diag::warn_pch_objc_auto_properties);
  95   PARSE_LANGOPT_BENIGN(ObjCInferRelatedResultType)
  96   PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings,
  97                           diag::warn_pch_no_constant_cfstrings);
  98   PARSE_LANGOPT_BENIGN(PascalStrings);
  99   PARSE_LANGOPT_BENIGN(WritableStrings);
 100   PARSE_LANGOPT_IMPORTANT(LaxVectorConversions,
 101                           diag::warn_pch_lax_vector_conversions);
 102   PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec);
 103   PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions);
 104   PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions);
 105   PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions);
 106   PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions);
 107   PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields);
 108   PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime);
 109   PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding);
 110   PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins);
 111   PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics,
 112                           diag::warn_pch_thread_safe_statics);
 113   PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads);
 114   PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks);
 115   PARSE_LANGOPT_BENIGN(EmitAllDecls);
 116   PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno);
 117   PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior());
 118   PARSE_LANGOPT_IMPORTANT(HeinousExtensions,
 119                           diag::warn_pch_heinous_extensions);
 120   // FIXME: Most of the options below are benign if the macro wasn't
 121   // used. Unfortunately, this means that a PCH compiled without
 122   // optimization can't be used with optimization turned on, even
 123   // though the only thing that changes is whether __OPTIMIZE__ was
 124   // defined... but if __OPTIMIZE__ never showed up in the header, it
 125   // doesn't matter. We could consider making this some special kind
 126   // of check.
 127   PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize);
 128   PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size);
 129   PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static);
 130   PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level);
 131   PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline);
 132   PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline);
 133   PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated);
 134   PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control);
 135   PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed);
 136   PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar);
 137   PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums);
 138   if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) {
 139     Reader.Diag(diag::warn_pch_gc_mode)
 140       << LangOpts.getGCMode() << PPLangOpts.getGCMode();
 141     return true;
 142   }
 143   PARSE_LANGOPT_BENIGN(getVisibilityMode());
 144   PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(),
 145                           diag::warn_pch_stack_protector);
 146   PARSE_LANGOPT_BENIGN(InstantiationDepth);
 147   PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl);
 148   PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda);
 149   PARSE_LANGOPT_BENIGN(CatchUndefined);
 150   PARSE_LANGOPT_BENIGN(DefaultFPContract);
 151   PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors);
 152   PARSE_LANGOPT_BENIGN(SpellChecking);
 153   PARSE_LANGOPT_IMPORTANT(ObjCAutoRefCount, diag::warn_pch_auto_ref_count);
 154   PARSE_LANGOPT_BENIGN(ObjCInferRelatedReturnType);
 155 #undef PARSE_LANGOPT_IMPORTANT
 156 #undef PARSE_LANGOPT_BENIGN
 157
 158   return false;
 159 }
 160
 161 bool PCHValidator::ReadTargetTriple(llvm::StringRef Triple) {
 162   if (Triple == PP.getTargetInfo().getTriple().str())
 163     return false;
 164
 165   Reader.Diag(diag::warn_pch_target_triple)
 166     << Triple << PP.getTargetInfo().getTriple().str();
 167   return true;
 168 }
 169
 170 namespace {
 171   struct EmptyStringRef {
 172     bool operator ()(llvm::StringRef r) const { return r.empty(); }
 173   };
 174   struct EmptyBlock {
 175     bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
 176   };
 177 }
 178
 179 static bool EqualConcatenations(llvm::SmallVector<llvm::StringRef, 2> L,
 180                                 PCHPredefinesBlocks R) {
 181   // First, sum up the lengths.
 182   unsigned LL = 0, RL = 0;
 183   for (unsigned I = 0, N = L.size(); I != N; ++I) {
 184     LL += L[I].size();
 185   }
 186   for (unsigned I = 0, N = R.size(); I != N; ++I) {
 187     RL += R[I].Data.size();
 188   }
 189   if (LL != RL)
 190     return false;
 191   if (LL == 0 && RL == 0)
 192     return true;
 193
 194   // Kick out empty parts, they confuse the algorithm below.
 195   L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
 196   R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
 197
 198   // Do it the hard way. At this point, both vectors must be non-empty.
 199   llvm::StringRef LR = L[0], RR = R[0].Data;
 200   unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
 201   (void) RN;
 202   for (;;) {
 203     // Compare the current pieces.
 204     if (LR.size() == RR.size()) {
 205       // If they're the same length, it's pretty easy.
 206       if (LR != RR)
 207         return false;
 208       // Both pieces are done, advance.
 209       ++LI;
 210       ++RI;
 211       // If either string is done, they're both done, since they're the same
 212       // length.
 213       if (LI == LN) {
 214         assert(RI == RN && "Strings not the same length after all?");
 215         return true;
 216       }
 217       LR = L[LI];
 218       RR = R[RI].Data;
 219     } else if (LR.size() < RR.size()) {
 220       // Right piece is longer.
 221       if (!RR.startswith(LR))
 222         return false;
 223       ++LI;
 224       assert(LI != LN && "Strings not the same length after all?");
 225       RR = RR.substr(LR.size());
 226       LR = L[LI];
 227     } else {
 228       // Left piece is longer.
 229       if (!LR.startswith(RR))
 230         return false;
 231       ++RI;
 232       assert(RI != RN && "Strings not the same length after all?");
 233       LR = LR.substr(RR.size());
 234       RR = R[RI].Data;
 235     }
 236   }
 237 }
 238
 239 static std::pair<FileID, llvm::StringRef::size_type>
 240 FindMacro(const PCHPredefinesBlocks &Buffers, llvm::StringRef MacroDef) {
 241   std::pair<FileID, llvm::StringRef::size_type> Res;
 242   for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
 243     Res.second = Buffers[I].Data.find(MacroDef);
 244     if (Res.second != llvm::StringRef::npos) {
 245       Res.first = Buffers[I].BufferID;
 246       break;
 247     }
 248   }
 249   return Res;
 250 }
 251
 252 bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
 253                                         llvm::StringRef OriginalFileName,
 254                                         std::string &SuggestedPredefines,
 255                                         FileManager &FileMgr) {
 256   // We are in the context of an implicit include, so the predefines buffer will
 257   // have a #include entry for the PCH file itself (as normalized by the
 258   // preprocessor initialization). Find it and skip over it in the checking
 259   // below.
 260   llvm::SmallString<256> PCHInclude;
 261   PCHInclude += "#include \"";
 262   PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr);
 263   PCHInclude += "\"\n";
 264   std::pair<llvm::StringRef,llvm::StringRef> Split =
 265     llvm::StringRef(PP.getPredefines()).split(PCHInclude.str());
 266   llvm::StringRef Left =  Split.first, Right = Split.second;
 267   if (Left == PP.getPredefines()) {
 268     Error("Missing PCH include entry!");
 269     return true;
 270   }
 271
 272   // If the concatenation of all the PCH buffers is equal to the adjusted
 273   // command line, we're done.
 274   llvm::SmallVector<llvm::StringRef, 2> CommandLine;
 275   CommandLine.push_back(Left);
 276   CommandLine.push_back(Right);
 277   if (EqualConcatenations(CommandLine, Buffers))
 278     return false;
 279
 280   SourceManager &SourceMgr = PP.getSourceManager();
 281
 282   // The predefines buffers are different. Determine what the differences are,
 283   // and whether they require us to reject the PCH file.
 284   llvm::SmallVector<llvm::StringRef, 8> PCHLines;
 285   for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
 286     Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 287
 288   llvm::SmallVector<llvm::StringRef, 8> CmdLineLines;
 289   Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 290
 291   // Pick out implicit #includes after the PCH and don't consider them for
 292   // validation; we will insert them into SuggestedPredefines so that the
 293   // preprocessor includes them.
 294   std::string IncludesAfterPCH;
 295   llvm::SmallVector<llvm::StringRef, 8> AfterPCHLines;
 296   Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 297   for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
 298     if (AfterPCHLines[i].startswith("#include ")) {
 299       IncludesAfterPCH += AfterPCHLines[i];
 300       IncludesAfterPCH += '\n';
 301     } else {
 302       CmdLineLines.push_back(AfterPCHLines[i]);
 303     }
 304   }
 305
 306   // Make sure we add the includes last into SuggestedPredefines before we
 307   // exit this function.
 308   struct AddIncludesRAII {
 309     std::string &SuggestedPredefines;
 310     std::string &IncludesAfterPCH;
 311
 312     AddIncludesRAII(std::string &SuggestedPredefines,
 313                     std::string &IncludesAfterPCH)
 314       : SuggestedPredefines(SuggestedPredefines),
 315         IncludesAfterPCH(IncludesAfterPCH) { }
 316     ~AddIncludesRAII() {
 317       SuggestedPredefines += IncludesAfterPCH;
 318     }
 319   } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
 320
 321   // Sort both sets of predefined buffer lines, since we allow some extra
 322   // definitions and they may appear at any point in the output.
 323   std::sort(CmdLineLines.begin(), CmdLineLines.end());
 324   std::sort(PCHLines.begin(), PCHLines.end());
 325
 326   // Determine which predefines that were used to build the PCH file are missing
 327   // from the command line.
 328   std::vector<llvm::StringRef> MissingPredefines;
 329   std::set_difference(PCHLines.begin(), PCHLines.end(),
 330                       CmdLineLines.begin(), CmdLineLines.end(),
 331                       std::back_inserter(MissingPredefines));
 332
 333   bool MissingDefines = false;
 334   bool ConflictingDefines = false;
 335   for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
 336     llvm::StringRef Missing = MissingPredefines[I];
 337     if (Missing.startswith("#include ")) {
 338       // An -include was specified when generating the PCH; it is included in
 339       // the PCH, just ignore it.
 340       continue;
 341     }
 342     if (!Missing.startswith("#define ")) {
 343       Reader.Diag(diag::warn_pch_compiler_options_mismatch);
 344       return true;
 345     }
 346
 347     // This is a macro definition. Determine the name of the macro we're
 348     // defining.
 349     std::string::size_type StartOfMacroName = strlen("#define ");
 350     std::string::size_type EndOfMacroName
 351       = Missing.find_first_of("( \n\r", StartOfMacroName);
 352     assert(EndOfMacroName != std::string::npos &&
 353            "Couldn't find the end of the macro name");
 354     llvm::StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
 355
 356     // Determine whether this macro was given a different definition on the
 357     // command line.
 358     std::string MacroDefStart = "#define " + MacroName.str();
 359     std::string::size_type MacroDefLen = MacroDefStart.size();
 360     llvm::SmallVector<llvm::StringRef, 8>::iterator ConflictPos
 361       = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
 362                          MacroDefStart);
 363     for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
 364       if (!ConflictPos->startswith(MacroDefStart)) {
 365         // Different macro; we're done.
 366         ConflictPos = CmdLineLines.end();
 367         break;
 368       }
 369
 370       assert(ConflictPos->size() > MacroDefLen &&
 371              "Invalid #define in predefines buffer?");
 372       if ((*ConflictPos)[MacroDefLen] != ' ' &&
 373           (*ConflictPos)[MacroDefLen] != '(')
 374         continue; // Longer macro name; keep trying.
 375
 376       // We found a conflicting macro definition.
 377       break;
 378     }
 379
 380     if (ConflictPos != CmdLineLines.end()) {
 381       Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
 382           << MacroName;
 383
 384       // Show the definition of this macro within the PCH file.
 385       std::pair<FileID, llvm::StringRef::size_type> MacroLoc =
 386           FindMacro(Buffers, Missing);
 387       assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!");
 388       SourceLocation PCHMissingLoc =
 389           SourceMgr.getLocForStartOfFile(MacroLoc.first)
 390             .getFileLocWithOffset(MacroLoc.second);
 391       Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
 392
 393       ConflictingDefines = true;
 394       continue;
 395     }
 396
 397     // If the macro doesn't conflict, then we'll just pick up the macro
 398     // definition from the PCH file. Warn the user that they made a mistake.
 399     if (ConflictingDefines)
 400       continue; // Don't complain if there are already conflicting defs
 401
 402     if (!MissingDefines) {
 403       Reader.Diag(diag::warn_cmdline_missing_macro_defs);
 404       MissingDefines = true;
 405     }
 406
 407     // Show the definition of this macro within the PCH file.
 408     std::pair<FileID, llvm::StringRef::size_type> MacroLoc =
 409         FindMacro(Buffers, Missing);
 410     assert(MacroLoc.second!=llvm::StringRef::npos && "Unable to find macro!");
 411     SourceLocation PCHMissingLoc =
 412         SourceMgr.getLocForStartOfFile(MacroLoc.first)
 413           .getFileLocWithOffset(MacroLoc.second);
 414     Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
 415   }
 416
 417   if (ConflictingDefines)
 418     return true;
 419
 420   // Determine what predefines were introduced based on command-line
 421   // parameters that were not present when building the PCH
 422   // file. Extra #defines are okay, so long as the identifiers being
 423   // defined were not used within the precompiled header.
 424   std::vector<llvm::StringRef> ExtraPredefines;
 425   std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
 426                       PCHLines.begin(), PCHLines.end(),
 427                       std::back_inserter(ExtraPredefines));
 428   for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
 429     llvm::StringRef &Extra = ExtraPredefines[I];
 430     if (!Extra.startswith("#define ")) {
 431       Reader.Diag(diag::warn_pch_compiler_options_mismatch);
 432       return true;
 433     }
 434
 435     // This is an extra macro definition. Determine the name of the
 436     // macro we're defining.
 437     std::string::size_type StartOfMacroName = strlen("#define ");
 438     std::string::size_type EndOfMacroName
 439       = Extra.find_first_of("( \n\r", StartOfMacroName);
 440     assert(EndOfMacroName != std::string::npos &&
 441            "Couldn't find the end of the macro name");
 442     llvm::StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
 443
 444     // Check whether this name was used somewhere in the PCH file. If
 445     // so, defining it as a macro could change behavior, so we reject
 446     // the PCH file.
 447     if (IdentifierInfo *II = Reader.get(MacroName)) {
 448       Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
 449       return true;
 450     }
 451
 452     // Add this definition to the suggested predefines buffer.
 453     SuggestedPredefines += Extra;
 454     SuggestedPredefines += '\n';
 455   }
 456
 457   // If we get here, it's because the predefines buffer had compatible
 458   // contents. Accept the PCH file.
 459   return false;
 460 }
 461
 462 void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
 463                                       unsigned ID) {
 464   PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
 465   ++NumHeaderInfos;
 466 }
 467
 468 void PCHValidator::ReadCounter(unsigned Value) {
 469   PP.setCounterValue(Value);
 470 }
 471
 472 //===----------------------------------------------------------------------===//
 473 // AST reader implementation
 474 //===----------------------------------------------------------------------===//
 475
 476 void
 477 ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
 478   DeserializationListener = Listener;
 479 }
 480
 481
 482 namespace {
 483 class ASTSelectorLookupTrait {
 484   ASTReader &Reader;
 485
 486 public:
 487   struct data_type {
 488     SelectorID ID;
 489     ObjCMethodList Instance, Factory;
 490   };
 491
 492   typedef Selector external_key_type;
 493   typedef external_key_type internal_key_type;
 494
 495   explicit ASTSelectorLookupTrait(ASTReader &Reader) : Reader(Reader) { }
 496
 497   static bool EqualKey(const internal_key_type& a,
 498                        const internal_key_type& b) {
 499     return a == b;
 500   }
 501
 502   static unsigned ComputeHash(Selector Sel) {
 503     return serialization::ComputeHash(Sel);
 504   }
 505
 506   // This hopefully will just get inlined and removed by the optimizer.
 507   static const internal_key_type&
 508   GetInternalKey(const external_key_type& x) { return x; }
 509
 510   static std::pair<unsigned, unsigned>
 511   ReadKeyDataLength(const unsigned char*& d) {
 512     using namespace clang::io;
 513     unsigned KeyLen = ReadUnalignedLE16(d);
 514     unsigned DataLen = ReadUnalignedLE16(d);
 515     return std::make_pair(KeyLen, DataLen);
 516   }
 517
 518   internal_key_type ReadKey(const unsigned char* d, unsigned) {
 519     using namespace clang::io;
 520     SelectorTable &SelTable = Reader.getContext()->Selectors;
 521     unsigned N = ReadUnalignedLE16(d);
 522     IdentifierInfo *FirstII
 523       = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
 524     if (N == 0)
 525       return SelTable.getNullarySelector(FirstII);
 526     else if (N == 1)
 527       return SelTable.getUnarySelector(FirstII);
 528
 529     llvm::SmallVector<IdentifierInfo *, 16> Args;
 530     Args.push_back(FirstII);
 531     for (unsigned I = 1; I != N; ++I)
 532       Args.push_back(Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)));
 533
 534     return SelTable.getSelector(N, Args.data());
 535   }
 536
 537   data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) {
 538     using namespace clang::io;
 539
 540     data_type Result;
 541
 542     Result.ID = ReadUnalignedLE32(d);
 543     unsigned NumInstanceMethods = ReadUnalignedLE16(d);
 544     unsigned NumFactoryMethods = ReadUnalignedLE16(d);
 545
 546     // Load instance methods
 547     ObjCMethodList *Prev = 0;
 548     for (unsigned I = 0; I != NumInstanceMethods; ++I) {
 549       ObjCMethodDecl *Method
 550         = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d)));
 551       if (!Result.Instance.Method) {
 552         // This is the first method, which is the easy case.
 553         Result.Instance.Method = Method;
 554         Prev = &Result.Instance;
 555         continue;
 556       }
 557
 558       ObjCMethodList *Mem =
 559         Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
 560       Prev->Next = new (Mem) ObjCMethodList(Method, 0);
 561       Prev = Prev->Next;
 562     }
 563
 564     // Load factory methods
 565     Prev = 0;
 566     for (unsigned I = 0; I != NumFactoryMethods; ++I) {
 567       ObjCMethodDecl *Method
 568         = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d)));
 569       if (!Result.Factory.Method) {
 570         // This is the first method, which is the easy case.
 571         Result.Factory.Method = Method;
 572         Prev = &Result.Factory;
 573         continue;
 574       }
 575
 576       ObjCMethodList *Mem =
 577         Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
 578       Prev->Next = new (Mem) ObjCMethodList(Method, 0);
 579       Prev = Prev->Next;
 580     }
 581
 582     return Result;
 583   }
 584 };
 585
 586 } // end anonymous namespace
 587
 588 /// \brief The on-disk hash table used for the global method pool.
 589 typedef OnDiskChainedHashTable<ASTSelectorLookupTrait>
 590   ASTSelectorLookupTable;
 591
 592 namespace clang {
 593 class ASTIdentifierLookupTrait {
 594   ASTReader &Reader;
 595   ASTReader::PerFileData &F;
 596
 597   // If we know the IdentifierInfo in advance, it is here and we will
 598   // not build a new one. Used when deserializing information about an
 599   // identifier that was constructed before the AST file was read.
 600   IdentifierInfo *KnownII;
 601
 602 public:
 603   typedef IdentifierInfo * data_type;
 604
 605   typedef const std::pair<const char*, unsigned> external_key_type;
 606
 607   typedef external_key_type internal_key_type;
 608
 609   ASTIdentifierLookupTrait(ASTReader &Reader, ASTReader::PerFileData &F,
 610                            IdentifierInfo *II = 0)
 611     : Reader(Reader), F(F), KnownII(II) { }
 612
 613   static bool EqualKey(const internal_key_type& a,
 614                        const internal_key_type& b) {
 615     return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0
 616                                   : false;
 617   }
 618
 619   static unsigned ComputeHash(const internal_key_type& a) {
 620     return llvm::HashString(llvm::StringRef(a.first, a.second));
 621   }
 622
 623   // This hopefully will just get inlined and removed by the optimizer.
 624   static const internal_key_type&
 625   GetInternalKey(const external_key_type& x) { return x; }
 626
 627   // This hopefully will just get inlined and removed by the optimizer.
 628   static const external_key_type&
 629   GetExternalKey(const internal_key_type& x) { return x; }
 630
 631   static std::pair<unsigned, unsigned>
 632   ReadKeyDataLength(const unsigned char*& d) {
 633     using namespace clang::io;
 634     unsigned DataLen = ReadUnalignedLE16(d);
 635     unsigned KeyLen = ReadUnalignedLE16(d);
 636     return std::make_pair(KeyLen, DataLen);
 637   }
 638
 639   static std::pair<const char*, unsigned>
 640   ReadKey(const unsigned char* d, unsigned n) {
 641     assert(n >= 2 && d[n-1] == '\0');
 642     return std::make_pair((const char*) d, n-1);
 643   }
 644
 645   IdentifierInfo *ReadData(const internal_key_type& k,
 646                            const unsigned char* d,
 647                            unsigned DataLen) {
 648     using namespace clang::io;
 649     IdentID ID = ReadUnalignedLE32(d);
 650     bool IsInteresting = ID & 0x01;
 651
 652     // Wipe out the "is interesting" bit.
 653     ID = ID >> 1;
 654
 655     if (!IsInteresting) {
 656       // For uninteresting identifiers, just build the IdentifierInfo
 657       // and associate it with the persistent ID.
 658       IdentifierInfo *II = KnownII;
 659       if (!II)
 660         II = &Reader.getIdentifierTable().getOwn(llvm::StringRef(k.first,
 661                                                                  k.second));
 662       Reader.SetIdentifierInfo(ID, II);
 663       II->setIsFromAST();
 664       return II;
 665     }
 666
 667     unsigned Bits = ReadUnalignedLE16(d);
 668     bool CPlusPlusOperatorKeyword = Bits & 0x01;
 669     Bits >>= 1;
 670     bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
 671     Bits >>= 1;
 672     bool Poisoned = Bits & 0x01;
 673     Bits >>= 1;
 674     bool ExtensionToken = Bits & 0x01;
 675     Bits >>= 1;
 676     bool hasMacroDefinition = Bits & 0x01;
 677     Bits >>= 1;
 678     unsigned ObjCOrBuiltinID = Bits & 0x3FF;
 679     Bits >>= 10;
 680
 681     assert(Bits == 0 && "Extra bits in the identifier?");
 682     DataLen -= 6;
 683
 684     // Build the IdentifierInfo itself and link the identifier ID with
 685     // the new IdentifierInfo.
 686     IdentifierInfo *II = KnownII;
 687     if (!II)
 688       II = &Reader.getIdentifierTable().getOwn(llvm::StringRef(k.first,
 689                                                                k.second));
 690     Reader.SetIdentifierInfo(ID, II);
 691
 692     // Set or check the various bits in the IdentifierInfo structure.
 693     // Token IDs are read-only.
 694     if (HasRevertedTokenIDToIdentifier)
 695       II->RevertTokenIDToIdentifier();
 696     II->setObjCOrBuiltinID(ObjCOrBuiltinID);
 697     assert(II->isExtensionToken() == ExtensionToken &&
 698            "Incorrect extension token flag");
 699     (void)ExtensionToken;
 700     II->setIsPoisoned(Poisoned);
 701     assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
 702            "Incorrect C++ operator keyword flag");
 703     (void)CPlusPlusOperatorKeyword;
 704
 705     // If this identifier is a macro, deserialize the macro
 706     // definition.
 707     if (hasMacroDefinition) {
 708       uint32_t Offset = ReadUnalignedLE32(d);
 709       Reader.SetIdentifierIsMacro(II, F, Offset);
 710       DataLen -= 4;
 711     }
 712
 713     // Read all of the declarations visible at global scope with this
 714     // name.
 715     if (Reader.getContext() == 0) return II;
 716     if (DataLen > 0) {
 717       llvm::SmallVector<uint32_t, 4> DeclIDs;
 718       for (; DataLen > 0; DataLen -= 4)
 719         DeclIDs.push_back(ReadUnalignedLE32(d));
 720       Reader.SetGloballyVisibleDecls(II, DeclIDs);
 721     }
 722
 723     II->setIsFromAST();
 724     return II;
 725   }
 726 };
 727
 728 } // end anonymous namespace
 729
 730 /// \brief The on-disk hash table used to contain information about
 731 /// all of the identifiers in the program.
 732 typedef OnDiskChainedHashTable<ASTIdentifierLookupTrait>
 733   ASTIdentifierLookupTable;
 734
 735 namespace {
 736 class ASTDeclContextNameLookupTrait {
 737   ASTReader &Reader;
 738
 739 public:
 740   /// \brief Pair of begin/end iterators for DeclIDs.
 741   typedef std::pair<DeclID *, DeclID *> data_type;
 742
 743   /// \brief Special internal key for declaration names.
 744   /// The hash table creates keys for comparison; we do not create
 745   /// a DeclarationName for the internal key to avoid deserializing types.
 746   struct DeclNameKey {
 747     DeclarationName::NameKind Kind;
 748     uint64_t Data;
 749     DeclNameKey() : Kind((DeclarationName::NameKind)0), Data(0) { }
 750   };
 751
 752   typedef DeclarationName external_key_type;
 753   typedef DeclNameKey internal_key_type;
 754
 755   explicit ASTDeclContextNameLookupTrait(ASTReader &Reader) : Reader(Reader) { }
 756
 757   static bool EqualKey(const internal_key_type& a,
 758                        const internal_key_type& b) {
 759     return a.Kind == b.Kind && a.Data == b.Data;
 760   }
 761
 762   unsigned ComputeHash(const DeclNameKey &Key) const {
 763     llvm::FoldingSetNodeID ID;
 764     ID.AddInteger(Key.Kind);
 765
 766     switch (Key.Kind) {
 767     case DeclarationName::Identifier:
 768     case DeclarationName::CXXLiteralOperatorName:
 769       ID.AddString(((IdentifierInfo*)Key.Data)->getName());
 770       break;
 771     case DeclarationName::ObjCZeroArgSelector:
 772     case DeclarationName::ObjCOneArgSelector:
 773     case DeclarationName::ObjCMultiArgSelector:
 774       ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
 775       break;
 776     case DeclarationName::CXXConstructorName:
 777     case DeclarationName::CXXDestructorName:
 778     case DeclarationName::CXXConversionFunctionName:
 779       ID.AddInteger((TypeID)Key.Data);
 780       break;
 781     case DeclarationName::CXXOperatorName:
 782       ID.AddInteger((OverloadedOperatorKind)Key.Data);
 783       break;
 784     case DeclarationName::CXXUsingDirective:
 785       break;
 786     }
 787
 788     return ID.ComputeHash();
 789   }
 790
 791   internal_key_type GetInternalKey(const external_key_type& Name) const {
 792     DeclNameKey Key;
 793     Key.Kind = Name.getNameKind();
 794     switch (Name.getNameKind()) {
 795     case DeclarationName::Identifier:
 796       Key.Data = (uint64_t)Name.getAsIdentifierInfo();
 797       break;
 798     case DeclarationName::ObjCZeroArgSelector:
 799     case DeclarationName::ObjCOneArgSelector:
 800     case DeclarationName::ObjCMultiArgSelector:
 801       Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
 802       break;
 803     case DeclarationName::CXXConstructorName:
 804     case DeclarationName::CXXDestructorName:
 805     case DeclarationName::CXXConversionFunctionName:
 806       Key.Data = Reader.GetTypeID(Name.getCXXNameType());
 807       break;
 808     case DeclarationName::CXXOperatorName:
 809       Key.Data = Name.getCXXOverloadedOperator();
 810       break;
 811     case DeclarationName::CXXLiteralOperatorName:
 812       Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
 813       break;
 814     case DeclarationName::CXXUsingDirective:
 815       break;
 816     }
 817
 818     return Key;
 819   }
 820
 821   external_key_type GetExternalKey(const internal_key_type& Key) const {
 822     ASTContext *Context = Reader.getContext();
 823     switch (Key.Kind) {
 824     case DeclarationName::Identifier:
 825       return DeclarationName((IdentifierInfo*)Key.Data);
 826
 827     case DeclarationName::ObjCZeroArgSelector:
 828     case DeclarationName::ObjCOneArgSelector:
 829     case DeclarationName::ObjCMultiArgSelector:
 830       return DeclarationName(Selector(Key.Data));
 831
 832     case DeclarationName::CXXConstructorName:
 833       return Context->DeclarationNames.getCXXConstructorName(
 834                            Context->getCanonicalType(Reader.GetType(Key.Data)));
 835
 836     case DeclarationName::CXXDestructorName:
 837       return Context->DeclarationNames.getCXXDestructorName(
 838                            Context->getCanonicalType(Reader.GetType(Key.Data)));
 839
 840     case DeclarationName::CXXConversionFunctionName:
 841       return Context->DeclarationNames.getCXXConversionFunctionName(
 842                            Context->getCanonicalType(Reader.GetType(Key.Data)));
 843
 844     case DeclarationName::CXXOperatorName:
 845       return Context->DeclarationNames.getCXXOperatorName(
 846                                          (OverloadedOperatorKind)Key.Data);
 847
 848     case DeclarationName::CXXLiteralOperatorName:
 849       return Context->DeclarationNames.getCXXLiteralOperatorName(
 850                                                      (IdentifierInfo*)Key.Data);
 851
 852     case DeclarationName::CXXUsingDirective:
 853       return DeclarationName::getUsingDirectiveName();
 854     }
 855
 856     llvm_unreachable("Invalid Name Kind ?");
 857   }
 858
 859   static std::pair<unsigned, unsigned>
 860   ReadKeyDataLength(const unsigned char*& d) {
 861     using namespace clang::io;
 862     unsigned KeyLen = ReadUnalignedLE16(d);
 863     unsigned DataLen = ReadUnalignedLE16(d);
 864     return std::make_pair(KeyLen, DataLen);
 865   }
 866
 867   internal_key_type ReadKey(const unsigned char* d, unsigned) {
 868     using namespace clang::io;
 869
 870     DeclNameKey Key;
 871     Key.Kind = (DeclarationName::NameKind)*d++;
 872     switch (Key.Kind) {
 873     case DeclarationName::Identifier:
 874       Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
 875       break;
 876     case DeclarationName::ObjCZeroArgSelector:
 877     case DeclarationName::ObjCOneArgSelector:
 878     case DeclarationName::ObjCMultiArgSelector:
 879       Key.Data =
 880          (uint64_t)Reader.DecodeSelector(ReadUnalignedLE32(d)).getAsOpaquePtr();
 881       break;
 882     case DeclarationName::CXXConstructorName:
 883     case DeclarationName::CXXDestructorName:
 884     case DeclarationName::CXXConversionFunctionName:
 885       Key.Data = ReadUnalignedLE32(d); // TypeID
 886       break;
 887     case DeclarationName::CXXOperatorName:
 888       Key.Data = *d++; // OverloadedOperatorKind
 889       break;
 890     case DeclarationName::CXXLiteralOperatorName:
 891       Key.Data = (uint64_t)Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
 892       break;
 893     case DeclarationName::CXXUsingDirective:
 894       break;
 895     }
 896
 897     return Key;
 898   }
 899
 900   data_type ReadData(internal_key_type, const unsigned char* d,
 901                      unsigned DataLen) {
 902     using namespace clang::io;
 903     unsigned NumDecls = ReadUnalignedLE16(d);
 904     DeclID *Start = (DeclID *)d;
 905     return std::make_pair(Start, Start + NumDecls);
 906   }
 907 };
 908
 909 } // end anonymous namespace
 910
 911 /// \brief The on-disk hash table used for the DeclContext's Name lookup table.
 912 typedef OnDiskChainedHashTable<ASTDeclContextNameLookupTrait>
 913   ASTDeclContextNameLookupTable;
 914
 915 bool ASTReader::ReadDeclContextStorage(llvm::BitstreamCursor &Cursor,
 916                                    const std::pair<uint64_t, uint64_t> &Offsets,
 917                                        DeclContextInfo &Info) {
 918   SavedStreamPosition SavedPosition(Cursor);
 919   // First the lexical decls.
 920   if (Offsets.first != 0) {
 921     Cursor.JumpToBit(Offsets.first);
 922
 923     RecordData Record;
 924     const char *Blob;
 925     unsigned BlobLen;
 926     unsigned Code = Cursor.ReadCode();
 927     unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
 928     if (RecCode != DECL_CONTEXT_LEXICAL) {
 929       Error("Expected lexical block");
 930       return true;
 931     }
 932
 933     Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob);
 934     Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair);
 935   } else {
 936     Info.LexicalDecls = 0;
 937     Info.NumLexicalDecls = 0;
 938   }
 939
 940   // Now the lookup table.
 941   if (Offsets.second != 0) {
 942     Cursor.JumpToBit(Offsets.second);
 943
 944     RecordData Record;
 945     const char *Blob;
 946     unsigned BlobLen;
 947     unsigned Code = Cursor.ReadCode();
 948     unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen);
 949     if (RecCode != DECL_CONTEXT_VISIBLE) {
 950       Error("Expected visible lookup table block");
 951       return true;
 952     }
 953     Info.NameLookupTableData
 954       = ASTDeclContextNameLookupTable::Create(
 955                     (const unsigned char *)Blob + Record[0],
 956                     (const unsigned char *)Blob,
 957                     ASTDeclContextNameLookupTrait(*this));
 958   } else {
 959     Info.NameLookupTableData = 0;
 960   }
 961
 962   return false;
 963 }
 964
 965 void ASTReader::Error(llvm::StringRef Msg) {
 966   Error(diag::err_fe_pch_malformed, Msg);
 967 }
 968
 969 void ASTReader::Error(unsigned DiagID,
 970                       llvm::StringRef Arg1, llvm::StringRef Arg2) {
 971   if (Diags.isDiagnosticInFlight())
 972     Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
 973   else
 974     Diag(DiagID) << Arg1 << Arg2;
 975 }
 976
 977 /// \brief Tell the AST listener about the predefines buffers in the chain.
 978 bool ASTReader::CheckPredefinesBuffers() {
 979   if (Listener)
 980     return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers,
 981                                           ActualOriginalFileName,
 982                                           SuggestedPredefines,
 983                                           FileMgr);
 984   return false;
 985 }
 986
 987 //===----------------------------------------------------------------------===//
 988 // Source Manager Deserialization
 989 //===----------------------------------------------------------------------===//
 990
 991 /// \brief Read the line table in the source manager block.
 992 /// \returns true if there was an error.
 993 bool ASTReader::ParseLineTable(PerFileData &F,
 994                                llvm::SmallVectorImpl<uint64_t> &Record) {
 995   unsigned Idx = 0;
 996   LineTableInfo &LineTable = SourceMgr.getLineTable();
 997
 998   // Parse the file names
 999   std::map<int, int> FileIDs;
1000   for (int I = 0, N = Record[Idx++]; I != N; ++I) {
1001     // Extract the file name
1002     unsigned FilenameLen = Record[Idx++];
1003     std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen);
1004     Idx += FilenameLen;
1005     MaybeAddSystemRootToFilename(Filename);
1006     FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1007   }
1008
1009   // Parse the line entries
1010   std::vector<LineEntry> Entries;
1011   while (Idx < Record.size()) {
1012     int FID = Record[Idx++];
1013
1014     // Extract the line entries
1015     unsigned NumEntries = Record[Idx++];
1016     assert(NumEntries && "Numentries is 00000");
1017     Entries.clear();
1018     Entries.reserve(NumEntries);
1019     for (unsigned I = 0; I != NumEntries; ++I) {
1020       unsigned FileOffset = Record[Idx++];
1021       unsigned LineNo = Record[Idx++];
1022       int FilenameID = FileIDs[Record[Idx++]];
1023       SrcMgr::CharacteristicKind FileKind
1024         = (SrcMgr::CharacteristicKind)Record[Idx++];
1025       unsigned IncludeOffset = Record[Idx++];
1026       Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1027                                        FileKind, IncludeOffset));
1028     }
1029     LineTable.AddEntry(FID, Entries);
1030   }
1031
1032   return false;
1033 }
1034
1035 namespace {
1036
1037 class ASTStatData {
1038 public:
1039   const ino_t ino;
1040   const dev_t dev;
1041   const mode_t mode;
1042   const time_t mtime;
1043   const off_t size;
1044
1045   ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s)
1046     : ino(i), dev(d), mode(mo), mtime(m), size(s) {}
1047 };
1048
1049 class ASTStatLookupTrait {
1050  public:
1051   typedef const char *external_key_type;
1052   typedef const char *internal_key_type;
1053
1054   typedef ASTStatData data_type;
1055
1056   static unsigned ComputeHash(const char *path) {
1057     return llvm::HashString(path);
1058   }
1059
1060   static internal_key_type GetInternalKey(const char *path) { return path; }
1061
1062   static bool EqualKey(internal_key_type a, internal_key_type b) {
1063     return strcmp(a, b) == 0;
1064   }
1065
1066   static std::pair<unsigned, unsigned>
1067   ReadKeyDataLength(const unsigned char*& d) {
1068     unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1069     unsigned DataLen = (unsigned) *d++;
1070     return std::make_pair(KeyLen + 1, DataLen);
1071   }
1072
1073   static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1074     return (const char *)d;
1075   }
1076
1077   static data_type ReadData(const internal_key_type, const unsigned char *d,
1078                             unsigned /*DataLen*/) {
1079     using namespace clang::io;
1080
1081     ino_t ino = (ino_t) ReadUnalignedLE32(d);
1082     dev_t dev = (dev_t) ReadUnalignedLE32(d);
1083     mode_t mode = (mode_t) ReadUnalignedLE16(d);
1084     time_t mtime = (time_t) ReadUnalignedLE64(d);
1085     off_t size = (off_t) ReadUnalignedLE64(d);
1086     return data_type(ino, dev, mode, mtime, size);
1087   }
1088 };
1089
1090 /// \brief stat() cache for precompiled headers.
1091 ///
1092 /// This cache is very similar to the stat cache used by pretokenized
1093 /// headers.
1094 class ASTStatCache : public FileSystemStatCache {
1095   typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy;
1096   CacheTy *Cache;
1097
1098   unsigned &NumStatHits, &NumStatMisses;
1099 public:
1100   ASTStatCache(const unsigned char *Buckets, const unsigned char *Base,
1101                unsigned &NumStatHits, unsigned &NumStatMisses)
1102     : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) {
1103     Cache = CacheTy::Create(Buckets, Base);
1104   }
1105
1106   ~ASTStatCache() { delete Cache; }
1107
1108   LookupResult getStat(const char *Path, struct stat &StatBuf,
1109                        int *FileDescriptor) {
1110     // Do the lookup for the file's data in the AST file.
1111     CacheTy::iterator I = Cache->find(Path);
1112
1113     // If we don't get a hit in the AST file just forward to 'stat'.
1114     if (I == Cache->end()) {
1115       ++NumStatMisses;
1116       return statChained(Path, StatBuf, FileDescriptor);
1117     }
1118
1119     ++NumStatHits;
1120     ASTStatData Data = *I;
1121
1122     StatBuf.st_ino = Data.ino;
1123     StatBuf.st_dev = Data.dev;
1124     StatBuf.st_mtime = Data.mtime;
1125     StatBuf.st_mode = Data.mode;
1126     StatBuf.st_size = Data.size;
1127     return CacheExists;
1128   }
1129 };
1130 } // end anonymous namespace
1131
1132
1133 /// \brief Read a source manager block
1134 ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(PerFileData &F) {
1135   using namespace SrcMgr;
1136
1137   llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1138
1139   // Set the source-location entry cursor to the current position in
1140   // the stream. This cursor will be used to read the contents of the
1141   // source manager block initially, and then lazily read
1142   // source-location entries as needed.
1143   SLocEntryCursor = F.Stream;
1144
1145   // The stream itself is going to skip over the source manager block.
1146   if (F.Stream.SkipBlock()) {
1147     Error("malformed block record in AST file");
1148     return Failure;
1149   }
1150
1151   // Enter the source manager block.
1152   if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1153     Error("malformed source manager block record in AST file");
1154     return Failure;
1155   }
1156
1157   RecordData Record;
1158   while (true) {
1159     unsigned Code = SLocEntryCursor.ReadCode();
1160     if (Code == llvm::bitc::END_BLOCK) {
1161       if (SLocEntryCursor.ReadBlockEnd()) {
1162         Error("error at end of Source Manager block in AST file");
1163         return Failure;
1164       }
1165       return Success;
1166     }
1167
1168     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1169       // No known subblocks, always skip them.
1170       SLocEntryCursor.ReadSubBlockID();
1171       if (SLocEntryCursor.SkipBlock()) {
1172         Error("malformed block record in AST file");
1173         return Failure;
1174       }
1175       continue;
1176     }
1177
1178     if (Code == llvm::bitc::DEFINE_ABBREV) {
1179       SLocEntryCursor.ReadAbbrevRecord();
1180       continue;
1181     }
1182
1183     // Read a record.
1184     const char *BlobStart;
1185     unsigned BlobLen;
1186     Record.clear();
1187     switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1188     default:  // Default behavior: ignore.
1189       break;
1190
1191     case SM_LINE_TABLE:
1192       if (ParseLineTable(F, Record))
1193         return Failure;
1194       break;
1195
1196     case SM_SLOC_FILE_ENTRY:
1197     case SM_SLOC_BUFFER_ENTRY:
1198     case SM_SLOC_EXPANSION_ENTRY:
1199       // Once we hit one of the source location entries, we're done.
1200       return Success;
1201     }
1202   }
1203 }
1204
1205 /// \brief If a header file is not found at the path that we expect it to be
1206 /// and the PCH file was moved from its original location, try to resolve the
1207 /// file by assuming that header+PCH were moved together and the header is in
1208 /// the same place relative to the PCH.
1209 static std::string
1210 resolveFileRelativeToOriginalDir(const std::string &Filename,
1211                                  const std::string &OriginalDir,
1212                                  const std::string &CurrDir) {
1213   assert(OriginalDir != CurrDir &&
1214          "No point trying to resolve the file if the PCH dir didn't change");
1215   using namespace llvm::sys;
1216   llvm::SmallString<128> filePath(Filename);
1217   fs::make_absolute(filePath);
1218   assert(path::is_absolute(OriginalDir));
1219   llvm::SmallString<128> currPCHPath(CurrDir);
1220
1221   path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1222                        fileDirE = path::end(path::parent_path(filePath));
1223   path::const_iterator origDirI = path::begin(OriginalDir),
1224                        origDirE = path::end(OriginalDir);
1225   // Skip the common path components from filePath and OriginalDir.
1226   while (fileDirI != fileDirE && origDirI != origDirE &&
1227          *fileDirI == *origDirI) {
1228     ++fileDirI;
1229     ++origDirI;
1230   }
1231   for (; origDirI != origDirE; ++origDirI)
1232     path::append(currPCHPath, "..");
1233   path::append(currPCHPath, fileDirI, fileDirE);
1234   path::append(currPCHPath, path::filename(Filename));
1235   return currPCHPath.str();
1236 }
1237
1238 /// \brief Get a cursor that's correctly positioned for reading the source
1239 /// location entry with the given ID.
1240 ASTReader::PerFileData *ASTReader::SLocCursorForID(unsigned ID) {
1241   assert(ID != 0 && ID <= TotalNumSLocEntries &&
1242          "SLocCursorForID should only be called for real IDs.");
1243
1244   ID -= 1;
1245   PerFileData *F = 0;
1246   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1247     F = Chain[N - I - 1];
1248     if (ID < F->LocalNumSLocEntries)
1249       break;
1250     ID -= F->LocalNumSLocEntries;
1251   }
1252   assert(F && F->LocalNumSLocEntries > ID && "Chain corrupted");
1253
1254   F->SLocEntryCursor.JumpToBit(F->SLocOffsets[ID]);
1255   return F;
1256 }
1257
1258 /// \brief Read in the source location entry with the given ID.
1259 ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(unsigned ID) {
1260   if (ID == 0)
1261     return Success;
1262
1263   if (ID > TotalNumSLocEntries) {
1264     Error("source location entry ID out-of-range for AST file");
1265     return Failure;
1266   }
1267
1268   PerFileData *F = SLocCursorForID(ID);
1269   llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1270
1271   ++NumSLocEntriesRead;
1272   unsigned Code = SLocEntryCursor.ReadCode();
1273   if (Code == llvm::bitc::END_BLOCK ||
1274       Code == llvm::bitc::ENTER_SUBBLOCK ||
1275       Code == llvm::bitc::DEFINE_ABBREV) {
1276     Error("incorrectly-formatted source location entry in AST file");
1277     return Failure;
1278   }
1279
1280   RecordData Record;
1281   const char *BlobStart;
1282   unsigned BlobLen;
1283   switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1284   default:
1285     Error("incorrectly-formatted source location entry in AST file");
1286     return Failure;
1287
1288   case SM_SLOC_FILE_ENTRY: {
1289     std::string Filename(BlobStart, BlobStart + BlobLen);
1290     MaybeAddSystemRootToFilename(Filename);
1291     const FileEntry *File = FileMgr.getFile(Filename);
1292     if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1293         OriginalDir != CurrentDir) {
1294       std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1295                                                               OriginalDir,
1296                                                               CurrentDir);
1297       if (!resolved.empty())
1298         File = FileMgr.getFile(resolved);
1299     }
1300     if (File == 0)
1301       File = FileMgr.getVirtualFile(Filename, (off_t)Record[4],
1302                                     (time_t)Record[5]);
1303     if (File == 0) {
1304       std::string ErrorStr = "could not find file '";
1305       ErrorStr += Filename;
1306       ErrorStr += "' referenced by AST file";
1307       Error(ErrorStr.c_str());
1308       return Failure;
1309     }
1310
1311     if (Record.size() < 6) {
1312       Error("source location entry is incorrect");
1313       return Failure;
1314     }
1315
1316     if (!DisableValidation &&
1317         ((off_t)Record[4] != File->getSize()
1318 #if !defined(LLVM_ON_WIN32)
1319         // In our regression testing, the Windows file system seems to
1320         // have inconsistent modification times that sometimes
1321         // erroneously trigger this error-handling path.
1322          || (time_t)Record[5] != File->getModificationTime()
1323 #endif
1324         )) {
1325       Error(diag::err_fe_pch_file_modified, Filename);
1326       return Failure;
1327     }
1328
1329     FileID FID = SourceMgr.createFileID(File, ReadSourceLocation(*F, Record[1]),
1330                                         (SrcMgr::CharacteristicKind)Record[2],
1331                                         ID, Record[0]);
1332     if (Record[3])
1333       const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile())
1334         .setHasLineDirectives();
1335
1336     break;
1337   }
1338
1339   case SM_SLOC_BUFFER_ENTRY: {
1340     const char *Name = BlobStart;
1341     unsigned Offset = Record[0];
1342     unsigned Code = SLocEntryCursor.ReadCode();
1343     Record.clear();
1344     unsigned RecCode
1345       = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen);
1346
1347     if (RecCode != SM_SLOC_BUFFER_BLOB) {
1348       Error("AST record has invalid code");
1349       return Failure;
1350     }
1351
1352     llvm::MemoryBuffer *Buffer
1353     = llvm::MemoryBuffer::getMemBuffer(llvm::StringRef(BlobStart, BlobLen - 1),
1354                                        Name);
1355     FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, Offset);
1356
1357     if (strcmp(Name, "<built-in>") == 0) {
1358       PCHPredefinesBlock Block = {
1359         BufferID,
1360         llvm::StringRef(BlobStart, BlobLen - 1)
1361       };
1362       PCHPredefinesBuffers.push_back(Block);
1363     }
1364
1365     break;
1366   }
1367
1368   case SM_SLOC_EXPANSION_ENTRY: {
1369     SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1370     SourceMgr.createInstantiationLoc(SpellingLoc,
1371                                      ReadSourceLocation(*F, Record[2]),
1372                                      ReadSourceLocation(*F, Record[3]),
1373                                      Record[4],
1374                                      ID,
1375                                      Record[0]);
1376     break;
1377   }
1378   }
1379
1380   return Success;
1381 }
1382
1383 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1384 /// specified cursor.  Read the abbreviations that are at the top of the block
1385 /// and then leave the cursor pointing into the block.
1386 bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor,
1387                                  unsigned BlockID) {
1388   if (Cursor.EnterSubBlock(BlockID)) {
1389     Error("malformed block record in AST file");
1390     return Failure;
1391   }
1392
1393   while (true) {
1394     uint64_t Offset = Cursor.GetCurrentBitNo();
1395     unsigned Code = Cursor.ReadCode();
1396
1397     // We expect all abbrevs to be at the start of the block.
1398     if (Code != llvm::bitc::DEFINE_ABBREV) {
1399       Cursor.JumpToBit(Offset);
1400       return false;
1401     }
1402     Cursor.ReadAbbrevRecord();
1403   }
1404 }
1405
1406 PreprocessedEntity *ASTReader::ReadMacroRecord(PerFileData &F, uint64_t Offset) {
1407   assert(PP && "Forgot to set Preprocessor ?");
1408   llvm::BitstreamCursor &Stream = F.MacroCursor;
1409
1410   // Keep track of where we are in the stream, then jump back there
1411   // after reading this macro.
1412   SavedStreamPosition SavedPosition(Stream);
1413
1414   Stream.JumpToBit(Offset);
1415   RecordData Record;
1416   llvm::SmallVector<IdentifierInfo*, 16> MacroArgs;
1417   MacroInfo *Macro = 0;
1418
1419   while (true) {
1420     unsigned Code = Stream.ReadCode();
1421     switch (Code) {
1422     case llvm::bitc::END_BLOCK:
1423       return 0;
1424
1425     case llvm::bitc::ENTER_SUBBLOCK:
1426       // No known subblocks, always skip them.
1427       Stream.ReadSubBlockID();
1428       if (Stream.SkipBlock()) {
1429         Error("malformed block record in AST file");
1430         return 0;
1431       }
1432       continue;
1433
1434     case llvm::bitc::DEFINE_ABBREV:
1435       Stream.ReadAbbrevRecord();
1436       continue;
1437     default: break;
1438     }
1439
1440     // Read a record.
1441     const char *BlobStart = 0;
1442     unsigned BlobLen = 0;
1443     Record.clear();
1444     PreprocessorRecordTypes RecType =
1445       (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart,
1446                                                  BlobLen);
1447     switch (RecType) {
1448     case PP_MACRO_OBJECT_LIKE:
1449     case PP_MACRO_FUNCTION_LIKE: {
1450       // If we already have a macro, that means that we've hit the end
1451       // of the definition of the macro we were looking for. We're
1452       // done.
1453       if (Macro)
1454         return 0;
1455
1456       IdentifierInfo *II = DecodeIdentifierInfo(Record[0]);
1457       if (II == 0) {
1458         Error("macro must have a name in AST file");
1459         return 0;
1460       }
1461       SourceLocation Loc = ReadSourceLocation(F, Record[1]);
1462       bool isUsed = Record[2];
1463
1464       MacroInfo *MI = PP->AllocateMacroInfo(Loc);
1465       MI->setIsUsed(isUsed);
1466       MI->setIsFromAST();
1467
1468       unsigned NextIndex = 3;
1469       if (RecType == PP_MACRO_FUNCTION_LIKE) {
1470         // Decode function-like macro info.
1471         bool isC99VarArgs = Record[3];
1472         bool isGNUVarArgs = Record[4];
1473         MacroArgs.clear();
1474         unsigned NumArgs = Record[5];
1475         NextIndex = 6 + NumArgs;
1476         for (unsigned i = 0; i != NumArgs; ++i)
1477           MacroArgs.push_back(DecodeIdentifierInfo(Record[6+i]));
1478
1479         // Install function-like macro info.
1480         MI->setIsFunctionLike();
1481         if (isC99VarArgs) MI->setIsC99Varargs();
1482         if (isGNUVarArgs) MI->setIsGNUVarargs();
1483         MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
1484                             PP->getPreprocessorAllocator());
1485       }
1486
1487       // Finally, install the macro.
1488       PP->setMacroInfo(II, MI);
1489
1490       // Remember that we saw this macro last so that we add the tokens that
1491       // form its body to it.
1492       Macro = MI;
1493
1494       if (NextIndex + 1 == Record.size() && PP->getPreprocessingRecord()) {
1495         // We have a macro definition. Load it now.
1496         PP->getPreprocessingRecord()->RegisterMacroDefinition(Macro,
1497                                         getMacroDefinition(Record[NextIndex]));
1498       }
1499
1500       ++NumMacrosRead;
1501       break;
1502     }
1503
1504     case PP_TOKEN: {
1505       // If we see a TOKEN before a PP_MACRO_*, then the file is
1506       // erroneous, just pretend we didn't see this.
1507       if (Macro == 0) break;
1508
1509       Token Tok;
1510       Tok.startToken();
1511       Tok.setLocation(ReadSourceLocation(F, Record[0]));
1512       Tok.setLength(Record[1]);
1513       if (IdentifierInfo *II = DecodeIdentifierInfo(Record[2]))
1514         Tok.setIdentifierInfo(II);
1515       Tok.setKind((tok::TokenKind)Record[3]);
1516       Tok.setFlag((Token::TokenFlags)Record[4]);
1517       Macro->AddTokenToBody(Tok);
1518       break;
1519     }
1520   }
1521   }
1522
1523   return 0;
1524 }
1525
1526 PreprocessedEntity *ASTReader::LoadPreprocessedEntity(PerFileData &F) {
1527   assert(PP && "Forgot to set Preprocessor ?");
1528   unsigned Code = F.PreprocessorDetailCursor.ReadCode();
1529   switch (Code) {
1530   case llvm::bitc::END_BLOCK:
1531     return 0;
1532
1533   case llvm::bitc::ENTER_SUBBLOCK:
1534     Error("unexpected subblock record in preprocessor detail block");
1535     return 0;
1536
1537   case llvm::bitc::DEFINE_ABBREV:
1538     Error("unexpected abbrevation record in preprocessor detail block");
1539     return 0;
1540
1541   default:
1542     break;
1543   }
1544
1545   if (!PP->getPreprocessingRecord()) {
1546     Error("no preprocessing record");
1547     return 0;
1548   }
1549
1550   // Read the record.
1551   PreprocessingRecord &PPRec = *PP->getPreprocessingRecord();
1552   const char *BlobStart = 0;
1553   unsigned BlobLen = 0;
1554   RecordData Record;
1555   PreprocessorDetailRecordTypes RecType =
1556     (PreprocessorDetailRecordTypes)F.PreprocessorDetailCursor.ReadRecord(
1557                                              Code, Record, BlobStart, BlobLen);
1558   switch (RecType) {
1559   case PPD_MACRO_EXPANSION: {
1560     if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0]))
1561       return PE;
1562
1563     MacroExpansion *ME =
1564       new (PPRec) MacroExpansion(DecodeIdentifierInfo(Record[3]),
1565                                  SourceRange(ReadSourceLocation(F, Record[1]),
1566                                              ReadSourceLocation(F, Record[2])),
1567                                  getMacroDefinition(Record[4]));
1568     PPRec.SetPreallocatedEntity(Record[0], ME);
1569     return ME;
1570   }
1571
1572   case PPD_MACRO_DEFINITION: {
1573     if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0]))
1574       return PE;
1575
1576     if (Record[1] > MacroDefinitionsLoaded.size()) {
1577       Error("out-of-bounds macro definition record");
1578       return 0;
1579     }
1580
1581     // Decode the identifier info and then check again; if the macro is
1582     // still defined and associated with the identifier,
1583     IdentifierInfo *II = DecodeIdentifierInfo(Record[4]);
1584     if (!MacroDefinitionsLoaded[Record[1] - 1]) {
1585       MacroDefinition *MD
1586         = new (PPRec) MacroDefinition(II,
1587                                       ReadSourceLocation(F, Record[5]),
1588                                       SourceRange(
1589                                             ReadSourceLocation(F, Record[2]),
1590                                             ReadSourceLocation(F, Record[3])));
1591
1592       PPRec.SetPreallocatedEntity(Record[0], MD);
1593       MacroDefinitionsLoaded[Record[1] - 1] = MD;
1594
1595       if (DeserializationListener)
1596         DeserializationListener->MacroDefinitionRead(Record[1], MD);
1597     }
1598
1599     return MacroDefinitionsLoaded[Record[1] - 1];
1600   }
1601
1602   case PPD_INCLUSION_DIRECTIVE: {
1603     if (PreprocessedEntity *PE = PPRec.getPreprocessedEntity(Record[0]))
1604       return PE;
1605
1606     const char *FullFileNameStart = BlobStart + Record[3];
1607     const FileEntry *File
1608       = PP->getFileManager().getFile(llvm::StringRef(FullFileNameStart,
1609                                                      BlobLen - Record[3]));
1610
1611     // FIXME: Stable encoding
1612     InclusionDirective::InclusionKind Kind
1613       = static_cast<InclusionDirective::InclusionKind>(Record[5]);
1614     InclusionDirective *ID
1615       = new (PPRec) InclusionDirective(PPRec, Kind,
1616                                        llvm::StringRef(BlobStart, Record[3]),
1617                                        Record[4],
1618                                        File,
1619                                  SourceRange(ReadSourceLocation(F, Record[1]),
1620                                              ReadSourceLocation(F, Record[2])));
1621     PPRec.SetPreallocatedEntity(Record[0], ID);
1622     return ID;
1623   }
1624   }
1625
1626   Error("invalid offset in preprocessor detail block");
1627   return 0;
1628 }
1629
1630 namespace {
1631   /// \brief Trait class used to search the on-disk hash table containing all of
1632   /// the header search information.
1633   ///
1634   /// The on-disk hash table contains a mapping from each header path to
1635   /// information about that header (how many times it has been included, its
1636   /// controlling macro, etc.). Note that we actually hash based on the
1637   /// filename, and support "deep" comparisons of file names based on current
1638   /// inode numbers, so that the search can cope with non-normalized path names
1639   /// and symlinks.
1640   class HeaderFileInfoTrait {
1641     const char *SearchPath;
1642     struct stat SearchPathStatBuf;
1643     llvm::Optional<int> SearchPathStatResult;
1644
1645     int StatSimpleCache(const char *Path, struct stat *StatBuf) {
1646       if (Path == SearchPath) {
1647         if (!SearchPathStatResult)
1648           SearchPathStatResult = stat(Path, &SearchPathStatBuf);
1649
1650         *StatBuf = SearchPathStatBuf;
1651         return *SearchPathStatResult;
1652       }
1653
1654       return stat(Path, StatBuf);
1655     }
1656
1657   public:
1658     typedef const char *external_key_type;
1659     typedef const char *internal_key_type;
1660
1661     typedef HeaderFileInfo data_type;
1662
1663     HeaderFileInfoTrait(const char *SearchPath = 0) : SearchPath(SearchPath) { }
1664
1665     static unsigned ComputeHash(const char *path) {
1666       return llvm::HashString(llvm::sys::path::filename(path));
1667     }
1668
1669     static internal_key_type GetInternalKey(const char *path) { return path; }
1670
1671     bool EqualKey(internal_key_type a, internal_key_type b) {
1672       if (strcmp(a, b) == 0)
1673         return true;
1674
1675       if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b))
1676         return false;
1677
1678       // The file names match, but the path names don't. stat() the files to
1679       // see if they are the same.
1680       struct stat StatBufA, StatBufB;
1681       if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB))
1682         return false;
1683
1684       return StatBufA.st_ino == StatBufB.st_ino;
1685     }
1686
1687     static std::pair<unsigned, unsigned>
1688     ReadKeyDataLength(const unsigned char*& d) {
1689       unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d);
1690       unsigned DataLen = (unsigned) *d++;
1691       return std::make_pair(KeyLen + 1, DataLen);
1692     }
1693
1694     static internal_key_type ReadKey(const unsigned char *d, unsigned) {
1695       return (const char *)d;
1696     }
1697
1698     static data_type ReadData(const internal_key_type, const unsigned char *d,
1699                               unsigned DataLen) {
1700       const unsigned char *End = d + DataLen;
1701       using namespace clang::io;
1702       HeaderFileInfo HFI;
1703       unsigned Flags = *d++;
1704       HFI.isImport = (Flags >> 4) & 0x01;
1705       HFI.isPragmaOnce = (Flags >> 3) & 0x01;
1706       HFI.DirInfo = (Flags >> 1) & 0x03;
1707       HFI.Resolved = Flags & 0x01;
1708       HFI.NumIncludes = ReadUnalignedLE16(d);
1709       HFI.ControllingMacroID = ReadUnalignedLE32(d);
1710       assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
1711       (void)End;
1712
1713       // This HeaderFileInfo was externally loaded.
1714       HFI.External = true;
1715       return HFI;
1716     }
1717   };
1718 }
1719
1720 /// \brief The on-disk hash table used for the global method pool.
1721 typedef OnDiskChainedHashTable<HeaderFileInfoTrait>
1722   HeaderFileInfoLookupTable;
1723
1724 void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, PerFileData &F,
1725                                      uint64_t Offset) {
1726   // Note that this identifier has a macro definition.
1727   II->setHasMacroDefinition(true);
1728
1729   // Adjust the offset based on our position in the chain.
1730   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1731     if (Chain[I] == &F)
1732       break;
1733
1734     Offset += Chain[I]->SizeInBits;
1735   }
1736
1737   UnreadMacroRecordOffsets[II] = Offset;
1738 }
1739
1740 void ASTReader::ReadDefinedMacros() {
1741   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1742     PerFileData &F = *Chain[N - I - 1];
1743     llvm::BitstreamCursor &MacroCursor = F.MacroCursor;
1744
1745     // If there was no preprocessor block, skip this file.
1746     if (!MacroCursor.getBitStreamReader())
1747       continue;
1748
1749     llvm::BitstreamCursor Cursor = MacroCursor;
1750     Cursor.JumpToBit(F.MacroStartOffset);
1751
1752     RecordData Record;
1753     while (true) {
1754       unsigned Code = Cursor.ReadCode();
1755       if (Code == llvm::bitc::END_BLOCK)
1756         break;
1757
1758       if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1759         // No known subblocks, always skip them.
1760         Cursor.ReadSubBlockID();
1761         if (Cursor.SkipBlock()) {
1762           Error("malformed block record in AST file");
1763           return;
1764         }
1765         continue;
1766       }
1767
1768       if (Code == llvm::bitc::DEFINE_ABBREV) {
1769         Cursor.ReadAbbrevRecord();
1770         continue;
1771       }
1772
1773       // Read a record.
1774       const char *BlobStart;
1775       unsigned BlobLen;
1776       Record.clear();
1777       switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
1778       default:  // Default behavior: ignore.
1779         break;
1780
1781       case PP_MACRO_OBJECT_LIKE:
1782       case PP_MACRO_FUNCTION_LIKE:
1783         DecodeIdentifierInfo(Record[0]);
1784         break;
1785
1786       case PP_TOKEN:
1787         // Ignore tokens.
1788         break;
1789       }
1790     }
1791   }
1792
1793   // Drain the unread macro-record offsets map.
1794   while (!UnreadMacroRecordOffsets.empty())
1795     LoadMacroDefinition(UnreadMacroRecordOffsets.begin());
1796 }
1797
1798 void ASTReader::LoadMacroDefinition(
1799                      llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) {
1800   assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition");
1801   PerFileData *F = 0;
1802   uint64_t Offset = Pos->second;
1803   UnreadMacroRecordOffsets.erase(Pos);
1804
1805   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1806     if (Offset < Chain[I]->SizeInBits) {
1807       F = Chain[I];
1808       break;
1809     }
1810
1811     Offset -= Chain[I]->SizeInBits;
1812   }
1813   if (!F) {
1814     Error("Malformed macro record offset");
1815     return;
1816   }
1817
1818   ReadMacroRecord(*F, Offset);
1819 }
1820
1821 void ASTReader::LoadMacroDefinition(IdentifierInfo *II) {
1822   llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos
1823     = UnreadMacroRecordOffsets.find(II);
1824   LoadMacroDefinition(Pos);
1825 }
1826
1827 MacroDefinition *ASTReader::getMacroDefinition(MacroID ID) {
1828   if (ID == 0 || ID > MacroDefinitionsLoaded.size())
1829     return 0;
1830
1831   if (!MacroDefinitionsLoaded[ID - 1]) {
1832     unsigned Index = ID - 1;
1833     for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
1834       PerFileData &F = *Chain[N - I - 1];
1835       if (Index < F.LocalNumMacroDefinitions) {
1836         SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
1837         F.PreprocessorDetailCursor.JumpToBit(F.MacroDefinitionOffsets[Index]);
1838         LoadPreprocessedEntity(F);
1839         break;
1840       }
1841       Index -= F.LocalNumMacroDefinitions;
1842     }
1843     assert(MacroDefinitionsLoaded[ID - 1] && "Broken chain");
1844   }
1845
1846   return MacroDefinitionsLoaded[ID - 1];
1847 }
1848
1849 const FileEntry *ASTReader::getFileEntry(llvm::StringRef filenameStrRef) {
1850   std::string Filename = filenameStrRef;
1851   MaybeAddSystemRootToFilename(Filename);
1852   const FileEntry *File = FileMgr.getFile(Filename);
1853   if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() &&
1854       OriginalDir != CurrentDir) {
1855     std::string resolved = resolveFileRelativeToOriginalDir(Filename,
1856                                                             OriginalDir,
1857                                                             CurrentDir);
1858     if (!resolved.empty())
1859       File = FileMgr.getFile(resolved);
1860   }
1861
1862   return File;
1863 }
1864
1865 /// \brief If we are loading a relocatable PCH file, and the filename is
1866 /// not an absolute path, add the system root to the beginning of the file
1867 /// name.
1868 void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) {
1869   // If this is not a relocatable PCH file, there's nothing to do.
1870   if (!RelocatablePCH)
1871     return;
1872
1873   if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
1874     return;
1875
1876   if (isysroot == 0) {
1877     // If no system root was given, default to '/'
1878     Filename.insert(Filename.begin(), '/');
1879     return;
1880   }
1881
1882   unsigned Length = strlen(isysroot);
1883   if (isysroot[Length - 1] != '/')
1884     Filename.insert(Filename.begin(), '/');
1885
1886   Filename.insert(Filename.begin(), isysroot, isysroot + Length);
1887 }
1888
1889 ASTReader::ASTReadResult
1890 ASTReader::ReadASTBlock(PerFileData &F) {
1891   llvm::BitstreamCursor &Stream = F.Stream;
1892
1893   if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
1894     Error("malformed block record in AST file");
1895     return Failure;
1896   }
1897
1898   // Read all of the records and blocks for the ASt file.
1899   RecordData Record;
1900   bool First = true;
1901   while (!Stream.AtEndOfStream()) {
1902     unsigned Code = Stream.ReadCode();
1903     if (Code == llvm::bitc::END_BLOCK) {
1904       if (Stream.ReadBlockEnd()) {
1905         Error("error at end of module block in AST file");
1906         return Failure;
1907       }
1908
1909       return Success;
1910     }
1911
1912     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
1913       switch (Stream.ReadSubBlockID()) {
1914       case DECLTYPES_BLOCK_ID:
1915         // We lazily load the decls block, but we want to set up the
1916         // DeclsCursor cursor to point into it.  Clone our current bitcode
1917         // cursor to it, enter the block and read the abbrevs in that block.
1918         // With the main cursor, we just skip over it.
1919         F.DeclsCursor = Stream;
1920         if (Stream.SkipBlock() ||  // Skip with the main cursor.
1921             // Read the abbrevs.
1922             ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
1923           Error("malformed block record in AST file");
1924           return Failure;
1925         }
1926         break;
1927
1928       case DECL_UPDATES_BLOCK_ID:
1929         if (Stream.SkipBlock()) {
1930           Error("malformed block record in AST file");
1931           return Failure;
1932         }
1933         break;
1934
1935       case PREPROCESSOR_BLOCK_ID:
1936         F.MacroCursor = Stream;
1937         if (PP)
1938           PP->setExternalSource(this);
1939
1940         if (Stream.SkipBlock() ||
1941             ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
1942           Error("malformed block record in AST file");
1943           return Failure;
1944         }
1945         F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
1946         break;
1947
1948       case PREPROCESSOR_DETAIL_BLOCK_ID:
1949         F.PreprocessorDetailCursor = Stream;
1950         if (Stream.SkipBlock() ||
1951             ReadBlockAbbrevs(F.PreprocessorDetailCursor,
1952                              PREPROCESSOR_DETAIL_BLOCK_ID)) {
1953           Error("malformed preprocessor detail record in AST file");
1954           return Failure;
1955         }
1956         F.PreprocessorDetailStartOffset
1957           = F.PreprocessorDetailCursor.GetCurrentBitNo();
1958         break;
1959
1960       case SOURCE_MANAGER_BLOCK_ID:
1961         switch (ReadSourceManagerBlock(F)) {
1962         case Success:
1963           break;
1964
1965         case Failure:
1966           Error("malformed source manager block in AST file");
1967           return Failure;
1968
1969         case IgnorePCH:
1970           return IgnorePCH;
1971         }
1972         break;
1973       }
1974       First = false;
1975       continue;
1976     }
1977
1978     if (Code == llvm::bitc::DEFINE_ABBREV) {
1979       Stream.ReadAbbrevRecord();
1980       continue;
1981     }
1982
1983     // Read and process a record.
1984     Record.clear();
1985     const char *BlobStart = 0;
1986     unsigned BlobLen = 0;
1987     switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record,
1988                                               &BlobStart, &BlobLen)) {
1989     default:  // Default behavior: ignore.
1990       break;
1991
1992     case METADATA: {
1993       if (Record[0] != VERSION_MAJOR && !DisableValidation) {
1994         Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
1995                                            : diag::warn_pch_version_too_new);
1996         return IgnorePCH;
1997       }
1998
1999       RelocatablePCH = Record[4];
2000       if (Listener) {
2001         std::string TargetTriple(BlobStart, BlobLen);
2002         if (Listener->ReadTargetTriple(TargetTriple))
2003           return IgnorePCH;
2004       }
2005       break;
2006     }
2007
2008     case CHAINED_METADATA: {
2009       if (!First) {
2010         Error("CHAINED_METADATA is not first record in block");
2011         return Failure;
2012       }
2013       if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2014         Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old
2015                                            : diag::warn_pch_version_too_new);
2016         return IgnorePCH;
2017       }
2018
2019       // Load the chained file, which is always a PCH file.
2020       switch(ReadASTCore(llvm::StringRef(BlobStart, BlobLen), PCH)) {
2021       case Failure: return Failure;
2022         // If we have to ignore the dependency, we'll have to ignore this too.
2023       case IgnorePCH: return IgnorePCH;
2024       case Success: break;
2025       }
2026       break;
2027     }
2028
2029     case TYPE_OFFSET:
2030       if (F.LocalNumTypes != 0) {
2031         Error("duplicate TYPE_OFFSET record in AST file");
2032         return Failure;
2033       }
2034       F.TypeOffsets = (const uint32_t *)BlobStart;
2035       F.LocalNumTypes = Record[0];
2036       break;
2037
2038     case DECL_OFFSET:
2039       if (F.LocalNumDecls != 0) {
2040         Error("duplicate DECL_OFFSET record in AST file");
2041         return Failure;
2042       }
2043       F.DeclOffsets = (const uint32_t *)BlobStart;
2044       F.LocalNumDecls = Record[0];
2045       break;
2046
2047     case TU_UPDATE_LEXICAL: {
2048       DeclContextInfo Info = {
2049         /* No visible information */ 0,
2050         reinterpret_cast<const KindDeclIDPair *>(BlobStart),
2051         BlobLen / sizeof(KindDeclIDPair)
2052       };
2053       DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0]
2054         .push_back(Info);
2055       break;
2056     }
2057
2058     case UPDATE_VISIBLE: {
2059       serialization::DeclID ID = Record[0];
2060       void *Table = ASTDeclContextNameLookupTable::Create(
2061                         (const unsigned char *)BlobStart + Record[1],
2062                         (const unsigned char *)BlobStart,
2063                         ASTDeclContextNameLookupTrait(*this));
2064       if (ID == 1 && Context) { // Is it the TU?
2065         DeclContextInfo Info = {
2066           Table, /* No lexical inforamtion */ 0, 0
2067         };
2068         DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info);
2069       } else
2070         PendingVisibleUpdates[ID].push_back(Table);
2071       break;
2072     }
2073
2074     case REDECLS_UPDATE_LATEST: {
2075       assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
2076       for (unsigned i = 0, e = Record.size(); i < e; i += 2) {
2077         DeclID First = Record[i], Latest = Record[i+1];
2078         assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() ||
2079                 Latest > FirstLatestDeclIDs[First]) &&
2080                "The new latest is supposed to come after the previous latest");
2081         FirstLatestDeclIDs[First] = Latest;
2082       }
2083       break;
2084     }
2085
2086     case LANGUAGE_OPTIONS:
2087       if (ParseLanguageOptions(Record) && !DisableValidation)
2088         return IgnorePCH;
2089       break;
2090
2091     case IDENTIFIER_TABLE:
2092       F.IdentifierTableData = BlobStart;
2093       if (Record[0]) {
2094         F.IdentifierLookupTable
2095           = ASTIdentifierLookupTable::Create(
2096                        (const unsigned char *)F.IdentifierTableData + Record[0],
2097                        (const unsigned char *)F.IdentifierTableData,
2098                        ASTIdentifierLookupTrait(*this, F));
2099         if (PP)
2100           PP->getIdentifierTable().setExternalIdentifierLookup(this);
2101       }
2102       break;
2103
2104     case IDENTIFIER_OFFSET:
2105       if (F.LocalNumIdentifiers != 0) {
2106         Error("duplicate IDENTIFIER_OFFSET record in AST file");
2107         return Failure;
2108       }
2109       F.IdentifierOffsets = (const uint32_t *)BlobStart;
2110       F.LocalNumIdentifiers = Record[0];
2111       break;
2112
2113     case EXTERNAL_DEFINITIONS:
2114       // Optimization for the first block.
2115       if (ExternalDefinitions.empty())
2116         ExternalDefinitions.swap(Record);
2117       else
2118         ExternalDefinitions.insert(ExternalDefinitions.end(),
2119                                    Record.begin(), Record.end());
2120       break;
2121
2122     case SPECIAL_TYPES:
2123       // Optimization for the first block
2124       if (SpecialTypes.empty())
2125         SpecialTypes.swap(Record);
2126       else
2127         SpecialTypes.insert(SpecialTypes.end(), Record.begin(), Record.end());
2128       break;
2129
2130     case STATISTICS:
2131       TotalNumStatements += Record[0];
2132       TotalNumMacros += Record[1];
2133       TotalLexicalDeclContexts += Record[2];
2134       TotalVisibleDeclContexts += Record[3];
2135       break;
2136
2137     case UNUSED_FILESCOPED_DECLS:
2138       // Optimization for the first block.
2139       if (UnusedFileScopedDecls.empty())
2140         UnusedFileScopedDecls.swap(Record);
2141       else
2142         UnusedFileScopedDecls.insert(UnusedFileScopedDecls.end(),
2143                                      Record.begin(), Record.end());
2144       break;
2145
2146     case DELEGATING_CTORS:
2147       // Optimization for the first block.
2148       if (DelegatingCtorDecls.empty())
2149         DelegatingCtorDecls.swap(Record);
2150       else
2151         DelegatingCtorDecls.insert(DelegatingCtorDecls.end(),
2152                                    Record.begin(), Record.end());
2153       break;
2154
2155     case WEAK_UNDECLARED_IDENTIFIERS:
2156       // Later blocks overwrite earlier ones.
2157       WeakUndeclaredIdentifiers.swap(Record);
2158       break;
2159
2160     case LOCALLY_SCOPED_EXTERNAL_DECLS:
2161       // Optimization for the first block.
2162       if (LocallyScopedExternalDecls.empty())
2163         LocallyScopedExternalDecls.swap(Record);
2164       else
2165         LocallyScopedExternalDecls.insert(LocallyScopedExternalDecls.end(),
2166                                           Record.begin(), Record.end());
2167       break;
2168
2169     case SELECTOR_OFFSETS:
2170       F.SelectorOffsets = (const uint32_t *)BlobStart;
2171       F.LocalNumSelectors = Record[0];
2172       break;
2173
2174     case METHOD_POOL:
2175       F.SelectorLookupTableData = (const unsigned char *)BlobStart;
2176       if (Record[0])
2177         F.SelectorLookupTable
2178           = ASTSelectorLookupTable::Create(
2179                         F.SelectorLookupTableData + Record[0],
2180                         F.SelectorLookupTableData,
2181                         ASTSelectorLookupTrait(*this));
2182       TotalNumMethodPoolEntries += Record[1];
2183       break;
2184
2185     case REFERENCED_SELECTOR_POOL:
2186       F.ReferencedSelectorsData.swap(Record);
2187       break;
2188
2189     case PP_COUNTER_VALUE:
2190       if (!Record.empty() && Listener)
2191         Listener->ReadCounter(Record[0]);
2192       break;
2193
2194     case SOURCE_LOCATION_OFFSETS:
2195       F.SLocOffsets = (const uint32_t *)BlobStart;
2196       F.LocalNumSLocEntries = Record[0];
2197       F.LocalSLocSize = Record[1];
2198       break;
2199
2200     case FILE_SOURCE_LOCATION_OFFSETS:
2201       F.SLocFileOffsets = (const uint32_t *)BlobStart;
2202       F.LocalNumSLocFileEntries = Record[0];
2203       break;
2204
2205     case SOURCE_LOCATION_PRELOADS:
2206       if (PreloadSLocEntries.empty())
2207         PreloadSLocEntries.swap(Record);
2208       else
2209         PreloadSLocEntries.insert(PreloadSLocEntries.end(),
2210             Record.begin(), Record.end());
2211       break;
2212
2213     case STAT_CACHE: {
2214       if (!DisableStatCache) {
2215         ASTStatCache *MyStatCache =
2216           new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2217                            (const unsigned char *)BlobStart,
2218                            NumStatHits, NumStatMisses);
2219         FileMgr.addStatCache(MyStatCache);
2220         F.StatCache = MyStatCache;
2221       }
2222       break;
2223     }
2224
2225     case EXT_VECTOR_DECLS:
2226       // Optimization for the first block.
2227       if (ExtVectorDecls.empty())
2228         ExtVectorDecls.swap(Record);
2229       else
2230         ExtVectorDecls.insert(ExtVectorDecls.end(),
2231                               Record.begin(), Record.end());
2232       break;
2233
2234     case VTABLE_USES:
2235       // Later tables overwrite earlier ones.
2236       VTableUses.swap(Record);
2237       break;
2238
2239     case DYNAMIC_CLASSES:
2240       // Optimization for the first block.
2241       if (DynamicClasses.empty())
2242         DynamicClasses.swap(Record);
2243       else
2244         DynamicClasses.insert(DynamicClasses.end(),
2245                               Record.begin(), Record.end());
2246       break;
2247
2248     case PENDING_IMPLICIT_INSTANTIATIONS:
2249       F.PendingInstantiations.swap(Record);
2250       break;
2251
2252     case SEMA_DECL_REFS:
2253       // Later tables overwrite earlier ones.
2254       SemaDeclRefs.swap(Record);
2255       break;
2256
2257     case ORIGINAL_FILE_NAME:
2258       // The primary AST will be the last to get here, so it will be the one
2259       // that's used.
2260       ActualOriginalFileName.assign(BlobStart, BlobLen);
2261       OriginalFileName = ActualOriginalFileName;
2262       MaybeAddSystemRootToFilename(OriginalFileName);
2263       break;
2264
2265     case ORIGINAL_FILE_ID:
2266       OriginalFileID = FileID::get(Record[0]);
2267       break;
2268
2269     case ORIGINAL_PCH_DIR:
2270       // The primary AST will be the last to get here, so it will be the one
2271       // that's used.
2272       OriginalDir.assign(BlobStart, BlobLen);
2273       break;
2274
2275     case VERSION_CONTROL_BRANCH_REVISION: {
2276       const std::string &CurBranch = getClangFullRepositoryVersion();
2277       llvm::StringRef ASTBranch(BlobStart, BlobLen);
2278       if (llvm::StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2279         Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
2280         return IgnorePCH;
2281       }
2282       break;
2283     }
2284
2285     case MACRO_DEFINITION_OFFSETS:
2286       F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
2287       F.NumPreallocatedPreprocessingEntities = Record[0];
2288       F.LocalNumMacroDefinitions = Record[1];
2289       break;
2290
2291     case DECL_UPDATE_OFFSETS: {
2292       if (Record.size() % 2 != 0) {
2293         Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2294         return Failure;
2295       }
2296       for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2297         DeclUpdateOffsets[static_cast<DeclID>(Record[I])]
2298             .push_back(std::make_pair(&F, Record[I+1]));
2299       break;
2300     }
2301
2302     case DECL_REPLACEMENTS: {
2303       if (Record.size() % 2 != 0) {
2304         Error("invalid DECL_REPLACEMENTS block in AST file");
2305         return Failure;
2306       }
2307       for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2308         ReplacedDecls[static_cast<DeclID>(Record[I])] =
2309             std::make_pair(&F, Record[I+1]);
2310       break;
2311     }
2312
2313     case CXX_BASE_SPECIFIER_OFFSETS: {
2314       if (F.LocalNumCXXBaseSpecifiers != 0) {
2315         Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2316         return Failure;
2317       }
2318
2319       F.LocalNumCXXBaseSpecifiers = Record[0];
2320       F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
2321       break;
2322     }
2323
2324     case DIAG_PRAGMA_MAPPINGS:
2325       if (Record.size() % 2 != 0) {
2326         Error("invalid DIAG_USER_MAPPINGS block in AST file");
2327         return Failure;
2328       }
2329       if (PragmaDiagMappings.empty())
2330         PragmaDiagMappings.swap(Record);
2331       else
2332         PragmaDiagMappings.insert(PragmaDiagMappings.end(),
2333                                 Record.begin(), Record.end());
2334       break;
2335
2336     case CUDA_SPECIAL_DECL_REFS:
2337       // Later tables overwrite earlier ones.
2338       CUDASpecialDeclRefs.swap(Record);
2339       break;
2340
2341     case HEADER_SEARCH_TABLE:
2342       F.HeaderFileInfoTableData = BlobStart;
2343       F.LocalNumHeaderFileInfos = Record[1];
2344       if (Record[0]) {
2345         F.HeaderFileInfoTable
2346           = HeaderFileInfoLookupTable::Create(
2347                    (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
2348                    (const unsigned char *)F.HeaderFileInfoTableData);
2349         if (PP)
2350           PP->getHeaderSearchInfo().SetExternalSource(this);
2351       }
2352       break;
2353
2354     case FP_PRAGMA_OPTIONS:
2355       // Later tables overwrite earlier ones.
2356       FPPragmaOptions.swap(Record);
2357       break;
2358
2359     case OPENCL_EXTENSIONS:
2360       // Later tables overwrite earlier ones.
2361       OpenCLExtensions.swap(Record);
2362       break;
2363
2364     case TENTATIVE_DEFINITIONS:
2365       // Optimization for the first block.
2366       if (TentativeDefinitions.empty())
2367         TentativeDefinitions.swap(Record);
2368       else
2369         TentativeDefinitions.insert(TentativeDefinitions.end(),
2370                                     Record.begin(), Record.end());
2371       break;
2372
2373     case KNOWN_NAMESPACES:
2374       // Optimization for the first block.
2375       if (KnownNamespaces.empty())
2376         KnownNamespaces.swap(Record);
2377       else
2378         KnownNamespaces.insert(KnownNamespaces.end(),
2379                                Record.begin(), Record.end());
2380       break;
2381     }
2382     First = false;
2383   }
2384   Error("premature end of bitstream in AST file");
2385   return Failure;
2386 }
2387
2388 ASTReader::ASTReadResult ASTReader::validateFileEntries() {
2389   for (unsigned CI = 0, CN = Chain.size(); CI != CN; ++CI) {
2390     PerFileData *F = Chain[CI];
2391     llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
2392
2393     for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) {
2394       SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]);
2395       unsigned Code = SLocEntryCursor.ReadCode();
2396       if (Code == llvm::bitc::END_BLOCK ||
2397           Code == llvm::bitc::ENTER_SUBBLOCK ||
2398           Code == llvm::bitc::DEFINE_ABBREV) {
2399         Error("incorrectly-formatted source location entry in AST file");
2400         return Failure;
2401       }
2402
2403       RecordData Record;
2404       const char *BlobStart;
2405       unsigned BlobLen;
2406       switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2407       default:
2408         Error("incorrectly-formatted source location entry in AST file");
2409         return Failure;
2410
2411       case SM_SLOC_FILE_ENTRY: {
2412         llvm::StringRef Filename(BlobStart, BlobLen);
2413         const FileEntry *File = getFileEntry(Filename);
2414
2415         if (File == 0) {
2416           std::string ErrorStr = "could not find file '";
2417           ErrorStr += Filename;
2418           ErrorStr += "' referenced by AST file";
2419           Error(ErrorStr.c_str());
2420           return IgnorePCH;
2421         }
2422
2423         if (Record.size() < 6) {
2424           Error("source location entry is incorrect");
2425           return Failure;
2426         }
2427
2428         // The stat info from the FileEntry came from the cached stat
2429         // info of the PCH, so we cannot trust it.
2430         struct stat StatBuf;
2431         if (::stat(File->getName(), &StatBuf) != 0) {
2432           StatBuf.st_size = File->getSize();
2433           StatBuf.st_mtime = File->getModificationTime();
2434         }
2435
2436         if (((off_t)Record[4] != StatBuf.st_size
2437 #if !defined(LLVM_ON_WIN32)
2438             // In our regression testing, the Windows file system seems to
2439             // have inconsistent modification times that sometimes
2440             // erroneously trigger this error-handling path.
2441              || (time_t)Record[5] != StatBuf.st_mtime
2442 #endif
2443             )) {
2444           Error(diag::err_fe_pch_file_modified, Filename);
2445           return IgnorePCH;
2446         }
2447
2448         break;
2449       }
2450       }
2451     }
2452   }
2453
2454   return Success;
2455 }
2456
2457 ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2458                                             ASTFileType Type) {
2459   switch(ReadASTCore(FileName, Type)) {
2460   case Failure: return Failure;
2461   case IgnorePCH: return IgnorePCH;
2462   case Success: break;
2463   }
2464
2465   // Here comes stuff that we only do once the entire chain is loaded.
2466
2467   if (!DisableValidation) {
2468     switch(validateFileEntries()) {
2469     case Failure: return Failure;
2470     case IgnorePCH: return IgnorePCH;
2471     case Success: break;
2472     }
2473   }
2474
2475   // Allocate space for loaded slocentries, identifiers, decls and types.
2476   unsigned TotalNumIdentifiers = 0, TotalNumTypes = 0, TotalNumDecls = 0,
2477            TotalNumPreallocatedPreprocessingEntities = 0, TotalNumMacroDefs = 0,
2478            TotalNumSelectors = 0;
2479   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2480     TotalNumSLocEntries += Chain[I]->LocalNumSLocEntries;
2481     NextSLocOffset += Chain[I]->LocalSLocSize;
2482     TotalNumIdentifiers += Chain[I]->LocalNumIdentifiers;
2483     TotalNumTypes += Chain[I]->LocalNumTypes;
2484     TotalNumDecls += Chain[I]->LocalNumDecls;
2485     TotalNumPreallocatedPreprocessingEntities +=
2486         Chain[I]->NumPreallocatedPreprocessingEntities;
2487     TotalNumMacroDefs += Chain[I]->LocalNumMacroDefinitions;
2488     TotalNumSelectors += Chain[I]->LocalNumSelectors;
2489   }
2490   SourceMgr.PreallocateSLocEntries(this, TotalNumSLocEntries, NextSLocOffset);
2491   IdentifiersLoaded.resize(TotalNumIdentifiers);
2492   TypesLoaded.resize(TotalNumTypes);
2493   DeclsLoaded.resize(TotalNumDecls);
2494   MacroDefinitionsLoaded.resize(TotalNumMacroDefs);
2495   if (PP) {
2496     if (TotalNumIdentifiers > 0)
2497       PP->getHeaderSearchInfo().SetExternalLookup(this);
2498     if (TotalNumPreallocatedPreprocessingEntities > 0) {
2499       if (!PP->getPreprocessingRecord())
2500         PP->createPreprocessingRecord(true);
2501       PP->getPreprocessingRecord()->SetExternalSource(*this,
2502                                      TotalNumPreallocatedPreprocessingEntities);
2503     }
2504   }
2505   SelectorsLoaded.resize(TotalNumSelectors);
2506   // Preload SLocEntries.
2507   for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
2508     ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
2509     if (Result != Success)
2510       return Result;
2511   }
2512
2513   // Check the predefines buffers.
2514   if (!DisableValidation && CheckPredefinesBuffers())
2515     return IgnorePCH;
2516
2517   if (PP) {
2518     // Initialization of keywords and pragmas occurs before the
2519     // AST file is read, so there may be some identifiers that were
2520     // loaded into the IdentifierTable before we intercepted the
2521     // creation of identifiers. Iterate through the list of known
2522     // identifiers and determine whether we have to establish
2523     // preprocessor definitions or top-level identifier declaration
2524     // chains for those identifiers.
2525     //
2526     // We copy the IdentifierInfo pointers to a small vector first,
2527     // since de-serializing declarations or macro definitions can add
2528     // new entries into the identifier table, invalidating the
2529     // iterators.
2530     llvm::SmallVector<IdentifierInfo *, 128> Identifiers;
2531     for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
2532                                 IdEnd = PP->getIdentifierTable().end();
2533          Id != IdEnd; ++Id)
2534       Identifiers.push_back(Id->second);
2535     // We need to search the tables in all files.
2536     for (unsigned J = 0, M = Chain.size(); J != M; ++J) {
2537       ASTIdentifierLookupTable *IdTable
2538         = (ASTIdentifierLookupTable *)Chain[J]->IdentifierLookupTable;
2539       // Not all AST files necessarily have identifier tables, only the useful
2540       // ones.
2541       if (!IdTable)
2542         continue;
2543       for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2544         IdentifierInfo *II = Identifiers[I];
2545         // Look in the on-disk hash tables for an entry for this identifier
2546         ASTIdentifierLookupTrait Info(*this, *Chain[J], II);
2547         std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
2548         ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
2549         if (Pos == IdTable->end())
2550           continue;
2551
2552         // Dereferencing the iterator has the effect of populating the
2553         // IdentifierInfo node with the various declarations it needs.
2554         (void)*Pos;
2555       }
2556     }
2557   }
2558
2559   if (Context)
2560     InitializeContext(*Context);
2561
2562   if (DeserializationListener)
2563     DeserializationListener->ReaderInitialized(this);
2564
2565   // If this AST file is a precompiled preamble, then set the main file ID of
2566   // the source manager to the file source file from which the preamble was
2567   // built. This is the only valid way to use a precompiled preamble.
2568   if (Type == Preamble) {
2569     if (OriginalFileID.isInvalid()) {
2570       SourceLocation Loc
2571         = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2572       if (Loc.isValid())
2573         OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
2574     }
2575
2576     if (!OriginalFileID.isInvalid())
2577       SourceMgr.SetPreambleFileID(OriginalFileID);
2578   }
2579
2580   return Success;
2581 }
2582
2583 ASTReader::ASTReadResult ASTReader::ReadASTCore(llvm::StringRef FileName,
2584                                                 ASTFileType Type) {
2585   PerFileData *Prev = Chain.empty() ? 0 : Chain.back();
2586   Chain.push_back(new PerFileData(Type));
2587   PerFileData &F = *Chain.back();
2588   if (Prev)
2589     Prev->NextInSource = &F;
2590   else
2591     FirstInSource = &F;
2592   F.Loaders.push_back(Prev);
2593
2594   // Set the AST file name.
2595   F.FileName = FileName;
2596
2597   if (FileName != "-") {
2598     CurrentDir = llvm::sys::path::parent_path(FileName);
2599     if (CurrentDir.empty()) CurrentDir = ".";
2600   }
2601
2602   if (!ASTBuffers.empty()) {
2603     F.Buffer.reset(ASTBuffers.back());
2604     ASTBuffers.pop_back();
2605     assert(F.Buffer && "Passed null buffer");
2606   } else {
2607     // Open the AST file.
2608     //
2609     // FIXME: This shouldn't be here, we should just take a raw_ostream.
2610     std::string ErrStr;
2611     llvm::error_code ec;
2612     if (FileName == "-") {
2613       ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2614       if (ec)
2615         ErrStr = ec.message();
2616     } else
2617       F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2618     if (!F.Buffer) {
2619       Error(ErrStr.c_str());
2620       return IgnorePCH;
2621     }
2622   }
2623
2624   // Initialize the stream
2625   F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2626                     (const unsigned char *)F.Buffer->getBufferEnd());
2627   llvm::BitstreamCursor &Stream = F.Stream;
2628   Stream.init(F.StreamFile);
2629   F.SizeInBits = F.Buffer->getBufferSize() * 8;
2630
2631   // Sniff for the signature.
2632   if (Stream.Read(8) != 'C' ||
2633       Stream.Read(8) != 'P' ||
2634       Stream.Read(8) != 'C' ||
2635       Stream.Read(8) != 'H') {
2636     Diag(diag::err_not_a_pch_file) << FileName;
2637     return Failure;
2638   }
2639
2640   while (!Stream.AtEndOfStream()) {
2641     unsigned Code = Stream.ReadCode();
2642
2643     if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2644       Error("invalid record at top-level of AST file");
2645       return Failure;
2646     }
2647
2648     unsigned BlockID = Stream.ReadSubBlockID();
2649
2650     // We only know the AST subblock ID.
2651     switch (BlockID) {
2652     case llvm::bitc::BLOCKINFO_BLOCK_ID:
2653       if (Stream.ReadBlockInfoBlock()) {
2654         Error("malformed BlockInfoBlock in AST file");
2655         return Failure;
2656       }
2657       break;
2658     case AST_BLOCK_ID:
2659       switch (ReadASTBlock(F)) {
2660       case Success:
2661         break;
2662
2663       case Failure:
2664         return Failure;
2665
2666       case IgnorePCH:
2667         // FIXME: We could consider reading through to the end of this
2668         // AST block, skipping subblocks, to see if there are other
2669         // AST blocks elsewhere.
2670
2671         // Clear out any preallocated source location entries, so that
2672         // the source manager does not try to resolve them later.
2673         SourceMgr.ClearPreallocatedSLocEntries();
2674
2675         // Remove the stat cache.
2676         if (F.StatCache)
2677           FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2678
2679         return IgnorePCH;
2680       }
2681       break;
2682     default:
2683       if (Stream.SkipBlock()) {
2684         Error("malformed block record in AST file");
2685         return Failure;
2686       }
2687       break;
2688     }
2689   }
2690
2691   return Success;
2692 }
2693
2694 void ASTReader::setPreprocessor(Preprocessor &pp) {
2695   PP = &pp;
2696
2697   unsigned TotalNum = 0;
2698   for (unsigned I = 0, N = Chain.size(); I != N; ++I)
2699     TotalNum += Chain[I]->NumPreallocatedPreprocessingEntities;
2700   if (TotalNum) {
2701     if (!PP->getPreprocessingRecord())
2702       PP->createPreprocessingRecord(true);
2703     PP->getPreprocessingRecord()->SetExternalSource(*this, TotalNum);
2704   }
2705 }
2706
2707 void ASTReader::InitializeContext(ASTContext &Ctx) {
2708   Context = &Ctx;
2709   assert(Context && "Passed null context!");
2710
2711   assert(PP && "Forgot to set Preprocessor ?");
2712   PP->getIdentifierTable().setExternalIdentifierLookup(this);
2713   PP->getHeaderSearchInfo().SetExternalLookup(this);
2714   PP->setExternalSource(this);
2715   PP->getHeaderSearchInfo().SetExternalSource(this);
2716
2717   // If we have an update block for the TU waiting, we have to add it before
2718   // deserializing the decl.
2719   DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2720   if (DCU != DeclContextOffsets.end()) {
2721     // Insertion could invalidate map, so grab vector.
2722     DeclContextInfos T;
2723     T.swap(DCU->second);
2724     DeclContextOffsets.erase(DCU);
2725     DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T);
2726   }
2727
2728   // Load the translation unit declaration
2729   GetTranslationUnitDecl();
2730
2731   // Load the special types.
2732   Context->setBuiltinVaListType(
2733     GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2734   if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID])
2735     Context->setObjCIdType(GetType(Id));
2736   if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR])
2737     Context->setObjCSelType(GetType(Sel));
2738   if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL])
2739     Context->setObjCProtoType(GetType(Proto));
2740   if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS])
2741     Context->setObjCClassType(GetType(Class));
2742
2743   if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING])
2744     Context->setCFConstantStringType(GetType(String));
2745   if (unsigned FastEnum
2746         = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
2747     Context->setObjCFastEnumerationStateType(GetType(FastEnum));
2748   if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
2749     QualType FileType = GetType(File);
2750     if (FileType.isNull()) {
2751       Error("FILE type is NULL");
2752       return;
2753     }
2754     if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
2755       Context->setFILEDecl(Typedef->getDecl());
2756     else {
2757       const TagType *Tag = FileType->getAs<TagType>();
2758       if (!Tag) {
2759         Error("Invalid FILE type in AST file");
2760         return;
2761       }
2762       Context->setFILEDecl(Tag->getDecl());
2763     }
2764   }
2765   if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
2766     QualType Jmp_bufType = GetType(Jmp_buf);
2767     if (Jmp_bufType.isNull()) {
2768       Error("jmp_bug type is NULL");
2769       return;
2770     }
2771     if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
2772       Context->setjmp_bufDecl(Typedef->getDecl());
2773     else {
2774       const TagType *Tag = Jmp_bufType->getAs<TagType>();
2775       if (!Tag) {
2776         Error("Invalid jmp_buf type in AST file");
2777         return;
2778       }
2779       Context->setjmp_bufDecl(Tag->getDecl());
2780     }
2781   }
2782   if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
2783     QualType Sigjmp_bufType = GetType(Sigjmp_buf);
2784     if (Sigjmp_bufType.isNull()) {
2785       Error("sigjmp_buf type is NULL");
2786       return;
2787     }
2788     if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
2789       Context->setsigjmp_bufDecl(Typedef->getDecl());
2790     else {
2791       const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
2792       assert(Tag && "Invalid sigjmp_buf type in AST file");
2793       Context->setsigjmp_bufDecl(Tag->getDecl());
2794     }
2795   }
2796   if (unsigned ObjCIdRedef
2797         = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION])
2798     Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
2799   if (unsigned ObjCClassRedef
2800       = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
2801     Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
2802   if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR])
2803     Context->setBlockDescriptorType(GetType(String));
2804   if (unsigned String
2805       = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
2806     Context->setBlockDescriptorExtendedType(GetType(String));
2807   if (unsigned ObjCSelRedef
2808       = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
2809     Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
2810   if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING])
2811     Context->setNSConstantStringType(GetType(String));
2812
2813   if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
2814     Context->setInt128Installed();
2815
2816   if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
2817     Context->AutoDeductTy = GetType(AutoDeduct);
2818   if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
2819     Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
2820
2821   ReadPragmaDiagnosticMappings(Context->getDiagnostics());
2822
2823   // If there were any CUDA special declarations, deserialize them.
2824   if (!CUDASpecialDeclRefs.empty()) {
2825     assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2826     Context->setcudaConfigureCallDecl(
2827                            cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2828   }
2829 }
2830
2831 /// \brief Retrieve the name of the original source file name
2832 /// directly from the AST file, without actually loading the AST
2833 /// file.
2834 std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2835                                              FileManager &FileMgr,
2836                                              Diagnostic &Diags) {
2837   // Open the AST file.
2838   std::string ErrStr;
2839   llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
2840   Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2841   if (!Buffer) {
2842     Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2843     return std::string();
2844   }
2845
2846   // Initialize the stream
2847   llvm::BitstreamReader StreamFile;
2848   llvm::BitstreamCursor Stream;
2849   StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
2850                   (const unsigned char *)Buffer->getBufferEnd());
2851   Stream.init(StreamFile);
2852
2853   // Sniff for the signature.
2854   if (Stream.Read(8) != 'C' ||
2855       Stream.Read(8) != 'P' ||
2856       Stream.Read(8) != 'C' ||
2857       Stream.Read(8) != 'H') {
2858     Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
2859     return std::string();
2860   }
2861
2862   RecordData Record;
2863   while (!Stream.AtEndOfStream()) {
2864     unsigned Code = Stream.ReadCode();
2865
2866     if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2867       unsigned BlockID = Stream.ReadSubBlockID();
2868
2869       // We only know the AST subblock ID.
2870       switch (BlockID) {
2871       case AST_BLOCK_ID:
2872         if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2873           Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2874           return std::string();
2875         }
2876         break;
2877
2878       default:
2879         if (Stream.SkipBlock()) {
2880           Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2881           return std::string();
2882         }
2883         break;
2884       }
2885       continue;
2886     }
2887
2888     if (Code == llvm::bitc::END_BLOCK) {
2889       if (Stream.ReadBlockEnd()) {
2890         Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
2891         return std::string();
2892       }
2893       continue;
2894     }
2895
2896     if (Code == llvm::bitc::DEFINE_ABBREV) {
2897       Stream.ReadAbbrevRecord();
2898       continue;
2899     }
2900
2901     Record.clear();
2902     const char *BlobStart = 0;
2903     unsigned BlobLen = 0;
2904     if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
2905           == ORIGINAL_FILE_NAME)
2906       return std::string(BlobStart, BlobLen);
2907   }
2908
2909   return std::string();
2910 }
2911
2912 /// \brief Parse the record that corresponds to a LangOptions data
2913 /// structure.
2914 ///
2915 /// This routine parses the language options from the AST file and then gives
2916 /// them to the AST listener if one is set.
2917 ///
2918 /// \returns true if the listener deems the file unacceptable, false otherwise.
2919 bool ASTReader::ParseLanguageOptions(
2920                              const llvm::SmallVectorImpl<uint64_t> &Record) {
2921   if (Listener) {
2922     LangOptions LangOpts;
2923
2924   #define PARSE_LANGOPT(Option)                  \
2925       LangOpts.Option = Record[Idx];             \
2926       ++Idx
2927
2928     unsigned Idx = 0;
2929     PARSE_LANGOPT(Trigraphs);
2930     PARSE_LANGOPT(BCPLComment);
2931     PARSE_LANGOPT(DollarIdents);
2932     PARSE_LANGOPT(AsmPreprocessor);
2933     PARSE_LANGOPT(GNUMode);
2934     PARSE_LANGOPT(GNUKeywords);
2935     PARSE_LANGOPT(ImplicitInt);
2936     PARSE_LANGOPT(Digraphs);
2937     PARSE_LANGOPT(HexFloats);
2938     PARSE_LANGOPT(C99);
2939     PARSE_LANGOPT(C1X);
2940     PARSE_LANGOPT(Microsoft);
2941     PARSE_LANGOPT(CPlusPlus);
2942     PARSE_LANGOPT(CPlusPlus0x);
2943     PARSE_LANGOPT(CXXOperatorNames);
2944     PARSE_LANGOPT(ObjC1);
2945     PARSE_LANGOPT(ObjC2);
2946     PARSE_LANGOPT(ObjCNonFragileABI);
2947     PARSE_LANGOPT(ObjCNonFragileABI2);
2948     PARSE_LANGOPT(AppleKext);
2949     PARSE_LANGOPT(ObjCDefaultSynthProperties);
2950     PARSE_LANGOPT(ObjCInferRelatedResultType);
2951     PARSE_LANGOPT(NoConstantCFStrings);
2952     PARSE_LANGOPT(PascalStrings);
2953     PARSE_LANGOPT(WritableStrings);
2954     PARSE_LANGOPT(LaxVectorConversions);
2955     PARSE_LANGOPT(AltiVec);
2956     PARSE_LANGOPT(Exceptions);
2957     PARSE_LANGOPT(ObjCExceptions);
2958     PARSE_LANGOPT(CXXExceptions);
2959     PARSE_LANGOPT(SjLjExceptions);
2960     PARSE_LANGOPT(MSBitfields);
2961     PARSE_LANGOPT(NeXTRuntime);
2962     PARSE_LANGOPT(Freestanding);
2963     PARSE_LANGOPT(NoBuiltin);
2964     PARSE_LANGOPT(ThreadsafeStatics);
2965     PARSE_LANGOPT(POSIXThreads);
2966     PARSE_LANGOPT(Blocks);
2967     PARSE_LANGOPT(EmitAllDecls);
2968     PARSE_LANGOPT(MathErrno);
2969     LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
2970                                        Record[Idx++]);
2971     PARSE_LANGOPT(HeinousExtensions);
2972     PARSE_LANGOPT(Optimize);
2973     PARSE_LANGOPT(OptimizeSize);
2974     PARSE_LANGOPT(Static);
2975     PARSE_LANGOPT(PICLevel);
2976     PARSE_LANGOPT(GNUInline);
2977     PARSE_LANGOPT(NoInline);
2978     PARSE_LANGOPT(Deprecated);
2979     PARSE_LANGOPT(AccessControl);
2980     PARSE_LANGOPT(CharIsSigned);
2981     PARSE_LANGOPT(ShortWChar);
2982     PARSE_LANGOPT(ShortEnums);
2983     LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
2984     LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
2985     LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
2986                                    Record[Idx++]);
2987     PARSE_LANGOPT(InstantiationDepth);
2988     PARSE_LANGOPT(OpenCL);
2989     PARSE_LANGOPT(CUDA);
2990     PARSE_LANGOPT(CatchUndefined);
2991     PARSE_LANGOPT(DefaultFPContract);
2992     PARSE_LANGOPT(ElideConstructors);
2993     PARSE_LANGOPT(SpellChecking);
2994     PARSE_LANGOPT(MRTD);
2995     PARSE_LANGOPT(ObjCAutoRefCount);
2996   #undef PARSE_LANGOPT
2997
2998     return Listener->ReadLanguageOptions(LangOpts);
2999   }
3000
3001   return false;
3002 }
3003
3004 void ASTReader::ReadPreprocessedEntities() {
3005   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3006     PerFileData &F = *Chain[I];
3007     if (!F.PreprocessorDetailCursor.getBitStreamReader())
3008       continue;
3009
3010     SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
3011     F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
3012     while (LoadPreprocessedEntity(F)) { }
3013   }
3014 }
3015
3016 PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
3017   PerFileData *F = 0;
3018   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3019     if (Offset < Chain[I]->SizeInBits) {
3020       F = Chain[I];
3021       break;
3022     }
3023
3024     Offset -= Chain[I]->SizeInBits;
3025   }
3026
3027   if (!F) {
3028     Error("Malformed preprocessed entity offset");
3029     return 0;
3030   }
3031
3032   // Keep track of where we are in the stream, then jump back there
3033   // after reading this entity.
3034   SavedStreamPosition SavedPosition(F->PreprocessorDetailCursor);
3035   F->PreprocessorDetailCursor.JumpToBit(Offset);
3036   return LoadPreprocessedEntity(*F);
3037 }
3038
3039 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3040   HeaderFileInfoTrait Trait(FE->getName());
3041   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3042     PerFileData &F = *Chain[I];
3043     HeaderFileInfoLookupTable *Table
3044       = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
3045     if (!Table)
3046       continue;
3047
3048     // Look in the on-disk hash table for an entry for this file name.
3049     HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
3050                                                           &Trait);
3051     if (Pos == Table->end())
3052       continue;
3053
3054     HeaderFileInfo HFI = *Pos;
3055     if (Listener)
3056       Listener->ReadHeaderFileInfo(HFI, FE->getUID());
3057
3058     return HFI;
3059   }
3060
3061   return HeaderFileInfo();
3062 }
3063
3064 void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3065   unsigned Idx = 0;
3066   while (Idx < PragmaDiagMappings.size()) {
3067     SourceLocation
3068       Loc = SourceLocation::getFromRawEncoding(PragmaDiagMappings[Idx++]);
3069     while (1) {
3070       assert(Idx < PragmaDiagMappings.size() &&
3071              "Invalid data, didn't find '-1' marking end of diag/map pairs");
3072       if (Idx >= PragmaDiagMappings.size())
3073         break; // Something is messed up but at least avoid infinite loop in
3074                // release build.
3075       unsigned DiagID = PragmaDiagMappings[Idx++];
3076       if (DiagID == (unsigned)-1)
3077         break; // no more diag/map pairs for this location.
3078       diag::Mapping Map = (diag::Mapping)PragmaDiagMappings[Idx++];
3079       Diag.setDiagnosticMapping(DiagID, Map, Loc);
3080     }
3081   }
3082 }
3083
3084 /// \brief Get the correct cursor and offset for loading a type.
3085 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3086   PerFileData *F = 0;
3087   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3088     F = Chain[N - I - 1];
3089     if (Index < F->LocalNumTypes)
3090       break;
3091     Index -= F->LocalNumTypes;
3092   }
3093   assert(F && F->LocalNumTypes > Index && "Broken chain");
3094   return RecordLocation(F, F->TypeOffsets[Index]);
3095 }
3096
3097 /// \brief Read and return the type with the given index..
3098 ///
3099 /// The index is the type ID, shifted and minus the number of predefs. This
3100 /// routine actually reads the record corresponding to the type at the given
3101 /// location. It is a helper routine for GetType, which deals with reading type
3102 /// IDs.
3103 QualType ASTReader::ReadTypeRecord(unsigned Index) {
3104   RecordLocation Loc = TypeCursorForIndex(Index);
3105   llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3106
3107   // Keep track of where we are in the stream, then jump back there
3108   // after reading this type.
3109   SavedStreamPosition SavedPosition(DeclsCursor);
3110
3111   ReadingKindTracker ReadingKind(Read_Type, *this);
3112
3113   // Note that we are loading a type record.
3114   Deserializing AType(this);
3115
3116   DeclsCursor.JumpToBit(Loc.Offset);
3117   RecordData Record;
3118   unsigned Code = DeclsCursor.ReadCode();
3119   switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3120   case TYPE_EXT_QUAL: {
3121     if (Record.size() != 2) {
3122       Error("Incorrect encoding of extended qualifier type");
3123       return QualType();
3124     }
3125     QualType Base = GetType(Record[0]);
3126     Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]);
3127     return Context->getQualifiedType(Base, Quals);
3128   }
3129
3130   case TYPE_COMPLEX: {
3131     if (Record.size() != 1) {
3132       Error("Incorrect encoding of complex type");
3133       return QualType();
3134     }
3135     QualType ElemType = GetType(Record[0]);
3136     return Context->getComplexType(ElemType);
3137   }
3138
3139   case TYPE_POINTER: {
3140     if (Record.size() != 1) {
3141       Error("Incorrect encoding of pointer type");
3142       return QualType();
3143     }
3144     QualType PointeeType = GetType(Record[0]);
3145     return Context->getPointerType(PointeeType);
3146   }
3147
3148   case TYPE_BLOCK_POINTER: {
3149     if (Record.size() != 1) {
3150       Error("Incorrect encoding of block pointer type");
3151       return QualType();
3152     }
3153     QualType PointeeType = GetType(Record[0]);
3154     return Context->getBlockPointerType(PointeeType);
3155   }
3156
3157   case TYPE_LVALUE_REFERENCE: {
3158     if (Record.size() != 2) {
3159       Error("Incorrect encoding of lvalue reference type");
3160       return QualType();
3161     }
3162     QualType PointeeType = GetType(Record[0]);
3163     return Context->getLValueReferenceType(PointeeType, Record[1]);
3164   }
3165
3166   case TYPE_RVALUE_REFERENCE: {
3167     if (Record.size() != 1) {
3168       Error("Incorrect encoding of rvalue reference type");
3169       return QualType();
3170     }
3171     QualType PointeeType = GetType(Record[0]);
3172     return Context->getRValueReferenceType(PointeeType);
3173   }
3174
3175   case TYPE_MEMBER_POINTER: {
3176     if (Record.size() != 2) {
3177       Error("Incorrect encoding of member pointer type");
3178       return QualType();
3179     }
3180     QualType PointeeType = GetType(Record[0]);
3181     QualType ClassType = GetType(Record[1]);
3182     if (PointeeType.isNull() || ClassType.isNull())
3183       return QualType();
3184
3185     return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3186   }
3187
3188   case TYPE_CONSTANT_ARRAY: {
3189     QualType ElementType = GetType(Record[0]);
3190     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3191     unsigned IndexTypeQuals = Record[2];
3192     unsigned Idx = 3;
3193     llvm::APInt Size = ReadAPInt(Record, Idx);
3194     return Context->getConstantArrayType(ElementType, Size,
3195                                          ASM, IndexTypeQuals);
3196   }
3197
3198   case TYPE_INCOMPLETE_ARRAY: {
3199     QualType ElementType = GetType(Record[0]);
3200     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3201     unsigned IndexTypeQuals = Record[2];
3202     return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3203   }
3204
3205   case TYPE_VARIABLE_ARRAY: {
3206     QualType ElementType = GetType(Record[0]);
3207     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3208     unsigned IndexTypeQuals = Record[2];
3209     SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3210     SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3211     return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3212                                          ASM, IndexTypeQuals,
3213                                          SourceRange(LBLoc, RBLoc));
3214   }
3215
3216   case TYPE_VECTOR: {
3217     if (Record.size() != 3) {
3218       Error("incorrect encoding of vector type in AST file");
3219       return QualType();
3220     }
3221
3222     QualType ElementType = GetType(Record[0]);
3223     unsigned NumElements = Record[1];
3224     unsigned VecKind = Record[2];
3225     return Context->getVectorType(ElementType, NumElements,
3226                                   (VectorType::VectorKind)VecKind);
3227   }
3228
3229   case TYPE_EXT_VECTOR: {
3230     if (Record.size() != 3) {
3231       Error("incorrect encoding of extended vector type in AST file");
3232       return QualType();
3233     }
3234
3235     QualType ElementType = GetType(Record[0]);
3236     unsigned NumElements = Record[1];
3237     return Context->getExtVectorType(ElementType, NumElements);
3238   }
3239
3240   case TYPE_FUNCTION_NO_PROTO: {
3241     if (Record.size() != 6) {
3242       Error("incorrect encoding of no-proto function type");
3243       return QualType();
3244     }
3245     QualType ResultType = GetType(Record[0]);
3246     FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3247                                (CallingConv)Record[4], Record[5]);
3248     return Context->getFunctionNoProtoType(ResultType, Info);
3249   }
3250
3251   case TYPE_FUNCTION_PROTO: {
3252     QualType ResultType = GetType(Record[0]);
3253
3254     FunctionProtoType::ExtProtoInfo EPI;
3255     EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3256                                         /*hasregparm*/ Record[2],
3257                                         /*regparm*/ Record[3],
3258                                         static_cast<CallingConv>(Record[4]),
3259                                         /*produces*/ Record[5]);
3260
3261     unsigned Idx = 6;
3262     unsigned NumParams = Record[Idx++];
3263     llvm::SmallVector<QualType, 16> ParamTypes;
3264     for (unsigned I = 0; I != NumParams; ++I)
3265       ParamTypes.push_back(GetType(Record[Idx++]));
3266
3267     EPI.Variadic = Record[Idx++];
3268     EPI.TypeQuals = Record[Idx++];
3269     EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3270     ExceptionSpecificationType EST =
3271         static_cast<ExceptionSpecificationType>(Record[Idx++]);
3272     EPI.ExceptionSpecType = EST;
3273     if (EST == EST_Dynamic) {
3274       EPI.NumExceptions = Record[Idx++];
3275       llvm::SmallVector<QualType, 2> Exceptions;
3276       for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3277         Exceptions.push_back(GetType(Record[Idx++]));
3278       EPI.Exceptions = Exceptions.data();
3279     } else if (EST == EST_ComputedNoexcept) {
3280       EPI.NoexceptExpr = ReadExpr(*Loc.F);
3281     }
3282     return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3283                                     EPI);
3284   }
3285
3286   case TYPE_UNRESOLVED_USING:
3287     return Context->getTypeDeclType(
3288              cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0])));
3289
3290   case TYPE_TYPEDEF: {
3291     if (Record.size() != 2) {
3292       Error("incorrect encoding of typedef type");
3293       return QualType();
3294     }
3295     TypedefNameDecl *Decl = cast<TypedefNameDecl>(GetDecl(Record[0]));
3296     QualType Canonical = GetType(Record[1]);
3297     if (!Canonical.isNull())
3298       Canonical = Context->getCanonicalType(Canonical);
3299     return Context->getTypedefType(Decl, Canonical);
3300   }
3301
3302   case TYPE_TYPEOF_EXPR:
3303     return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3304
3305   case TYPE_TYPEOF: {
3306     if (Record.size() != 1) {
3307       Error("incorrect encoding of typeof(type) in AST file");
3308       return QualType();
3309     }
3310     QualType UnderlyingType = GetType(Record[0]);
3311     return Context->getTypeOfType(UnderlyingType);
3312   }
3313
3314   case TYPE_DECLTYPE:
3315     return Context->getDecltypeType(ReadExpr(*Loc.F));
3316
3317   case TYPE_UNARY_TRANSFORM: {
3318     QualType BaseType = GetType(Record[0]);
3319     QualType UnderlyingType = GetType(Record[1]);
3320     UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3321     return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3322   }
3323
3324   case TYPE_AUTO:
3325     return Context->getAutoType(GetType(Record[0]));
3326
3327   case TYPE_RECORD: {
3328     if (Record.size() != 2) {
3329       Error("incorrect encoding of record type");
3330       return QualType();
3331     }
3332     bool IsDependent = Record[0];
3333     QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1])));
3334     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3335     return T;
3336   }
3337
3338   case TYPE_ENUM: {
3339     if (Record.size() != 2) {
3340       Error("incorrect encoding of enum type");
3341       return QualType();
3342     }
3343     bool IsDependent = Record[0];
3344     QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1])));
3345     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3346     return T;
3347   }
3348
3349   case TYPE_ATTRIBUTED: {
3350     if (Record.size() != 3) {
3351       Error("incorrect encoding of attributed type");
3352       return QualType();
3353     }
3354     QualType modifiedType = GetType(Record[0]);
3355     QualType equivalentType = GetType(Record[1]);
3356     AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3357     return Context->getAttributedType(kind, modifiedType, equivalentType);
3358   }
3359
3360   case TYPE_PAREN: {
3361     if (Record.size() != 1) {
3362       Error("incorrect encoding of paren type");
3363       return QualType();
3364     }
3365     QualType InnerType = GetType(Record[0]);
3366     return Context->getParenType(InnerType);
3367   }
3368
3369   case TYPE_PACK_EXPANSION: {
3370     if (Record.size() != 2) {
3371       Error("incorrect encoding of pack expansion type");
3372       return QualType();
3373     }
3374     QualType Pattern = GetType(Record[0]);
3375     if (Pattern.isNull())
3376       return QualType();
3377     llvm::Optional<unsigned> NumExpansions;
3378     if (Record[1])
3379       NumExpansions = Record[1] - 1;
3380     return Context->getPackExpansionType(Pattern, NumExpansions);
3381   }
3382
3383   case TYPE_ELABORATED: {
3384     unsigned Idx = 0;
3385     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3386     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3387     QualType NamedType = GetType(Record[Idx++]);
3388     return Context->getElaboratedType(Keyword, NNS, NamedType);
3389   }
3390
3391   case TYPE_OBJC_INTERFACE: {
3392     unsigned Idx = 0;
3393     ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++]));
3394     return Context->getObjCInterfaceType(ItfD);
3395   }
3396
3397   case TYPE_OBJC_OBJECT: {
3398     unsigned Idx = 0;
3399     QualType Base = GetType(Record[Idx++]);
3400     unsigned NumProtos = Record[Idx++];
3401     llvm::SmallVector<ObjCProtocolDecl*, 4> Protos;
3402     for (unsigned I = 0; I != NumProtos; ++I)
3403       Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++])));
3404     return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3405   }
3406
3407   case TYPE_OBJC_OBJECT_POINTER: {
3408     unsigned Idx = 0;
3409     QualType Pointee = GetType(Record[Idx++]);
3410     return Context->getObjCObjectPointerType(Pointee);
3411   }
3412
3413   case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3414     unsigned Idx = 0;
3415     QualType Parm = GetType(Record[Idx++]);
3416     QualType Replacement = GetType(Record[Idx++]);
3417     return
3418       Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3419                                             Replacement);
3420   }
3421
3422   case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3423     unsigned Idx = 0;
3424     QualType Parm = GetType(Record[Idx++]);
3425     TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3426     return Context->getSubstTemplateTypeParmPackType(
3427                                                cast<TemplateTypeParmType>(Parm),
3428                                                      ArgPack);
3429   }
3430
3431   case TYPE_INJECTED_CLASS_NAME: {
3432     CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0]));
3433     QualType TST = GetType(Record[1]); // probably derivable
3434     // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3435     // for AST reading, too much interdependencies.
3436     return
3437       QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3438   }
3439
3440   case TYPE_TEMPLATE_TYPE_PARM: {
3441     unsigned Idx = 0;
3442     unsigned Depth = Record[Idx++];
3443     unsigned Index = Record[Idx++];
3444     bool Pack = Record[Idx++];
3445     TemplateTypeParmDecl *D =
3446       cast_or_null<TemplateTypeParmDecl>(GetDecl(Record[Idx++]));
3447     return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
3448   }
3449
3450   case TYPE_DEPENDENT_NAME: {
3451     unsigned Idx = 0;
3452     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3453     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3454     const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3455     QualType Canon = GetType(Record[Idx++]);
3456     if (!Canon.isNull())
3457       Canon = Context->getCanonicalType(Canon);
3458     return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3459   }
3460
3461   case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3462     unsigned Idx = 0;
3463     ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3464     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3465     const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3466     unsigned NumArgs = Record[Idx++];
3467     llvm::SmallVector<TemplateArgument, 8> Args;
3468     Args.reserve(NumArgs);
3469     while (NumArgs--)
3470       Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3471     return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3472                                                       Args.size(), Args.data());
3473   }
3474
3475   case TYPE_DEPENDENT_SIZED_ARRAY: {
3476     unsigned Idx = 0;
3477
3478     // ArrayType
3479     QualType ElementType = GetType(Record[Idx++]);
3480     ArrayType::ArraySizeModifier ASM
3481       = (ArrayType::ArraySizeModifier)Record[Idx++];
3482     unsigned IndexTypeQuals = Record[Idx++];
3483
3484     // DependentSizedArrayType
3485     Expr *NumElts = ReadExpr(*Loc.F);
3486     SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3487
3488     return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3489                                                IndexTypeQuals, Brackets);
3490   }
3491
3492   case TYPE_TEMPLATE_SPECIALIZATION: {
3493     unsigned Idx = 0;
3494     bool IsDependent = Record[Idx++];
3495     TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3496     llvm::SmallVector<TemplateArgument, 8> Args;
3497     ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3498     QualType Underlying = GetType(Record[Idx++]);
3499     QualType T;
3500     if (Underlying.isNull())
3501       T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3502                                                           Args.size());
3503     else
3504       T = Context->getTemplateSpecializationType(Name, Args.data(),
3505                                                  Args.size(), Underlying);
3506     const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3507     return T;
3508   }
3509   }
3510   // Suppress a GCC warning
3511   return QualType();
3512 }
3513
3514 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3515   ASTReader &Reader;
3516   ASTReader::PerFileData &F;
3517   llvm::BitstreamCursor &DeclsCursor;
3518   const ASTReader::RecordData &Record;
3519   unsigned &Idx;
3520
3521   SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3522                                     unsigned &I) {
3523     return Reader.ReadSourceLocation(F, R, I);
3524   }
3525
3526 public:
3527   TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F,
3528                 const ASTReader::RecordData &Record, unsigned &Idx)
3529     : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3530   { }
3531
3532   // We want compile-time assurance that we've enumerated all of
3533   // these, so unfortunately we have to declare them first, then
3534   // define them out-of-line.
3535 #define ABSTRACT_TYPELOC(CLASS, PARENT)
3536 #define TYPELOC(CLASS, PARENT) \
3537   void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3538 #include "clang/AST/TypeLocNodes.def"
3539
3540   void VisitFunctionTypeLoc(FunctionTypeLoc);
3541   void VisitArrayTypeLoc(ArrayTypeLoc);
3542 };
3543
3544 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3545   // nothing to do
3546 }
3547 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3548   TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3549   if (TL.needsExtraLocalData()) {
3550     TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3551     TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3552     TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3553     TL.setModeAttr(Record[Idx++]);
3554   }
3555 }
3556 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3557   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3558 }
3559 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3560   TL.setStarLoc(ReadSourceLocation(Record, Idx));
3561 }
3562 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3563   TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3564 }
3565 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3566   TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3567 }
3568 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3569   TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3570 }
3571 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3572   TL.setStarLoc(ReadSourceLocation(Record, Idx));
3573   TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3574 }
3575 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3576   TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3577   TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3578   if (Record[Idx++])
3579     TL.setSizeExpr(Reader.ReadExpr(F));
3580   else
3581     TL.setSizeExpr(0);
3582 }
3583 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3584   VisitArrayTypeLoc(TL);
3585 }
3586 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3587   VisitArrayTypeLoc(TL);
3588 }
3589 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3590   VisitArrayTypeLoc(TL);
3591 }
3592 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3593                                             DependentSizedArrayTypeLoc TL) {
3594   VisitArrayTypeLoc(TL);
3595 }
3596 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3597                                         DependentSizedExtVectorTypeLoc TL) {
3598   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3599 }
3600 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3601   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3602 }
3603 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3604   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3605 }
3606 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3607   TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3608   TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3609   TL.setTrailingReturn(Record[Idx++]);
3610   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3611     TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
3612   }
3613 }
3614 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3615   VisitFunctionTypeLoc(TL);
3616 }
3617 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3618   VisitFunctionTypeLoc(TL);
3619 }
3620 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3621   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3622 }
3623 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3624   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3625 }
3626 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3627   TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3628   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3629   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3630 }
3631 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3632   TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3633   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3634   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3635   TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3636 }
3637 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3638   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3639 }
3640 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3641   TL.setKWLoc(ReadSourceLocation(Record, Idx));
3642   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3643   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3644   TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3645 }
3646 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3647   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3648 }
3649 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3650   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3651 }
3652 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3653   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3654 }
3655 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3656   TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3657   if (TL.hasAttrOperand()) {
3658     SourceRange range;
3659     range.setBegin(ReadSourceLocation(Record, Idx));
3660     range.setEnd(ReadSourceLocation(Record, Idx));
3661     TL.setAttrOperandParensRange(range);
3662   }
3663   if (TL.hasAttrExprOperand()) {
3664     if (Record[Idx++])
3665       TL.setAttrExprOperand(Reader.ReadExpr(F));
3666     else
3667       TL.setAttrExprOperand(0);
3668   } else if (TL.hasAttrEnumOperand())
3669     TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3670 }
3671 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3672   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3673 }
3674 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3675                                             SubstTemplateTypeParmTypeLoc TL) {
3676   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3677 }
3678 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3679                                           SubstTemplateTypeParmPackTypeLoc TL) {
3680   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3681 }
3682 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3683                                            TemplateSpecializationTypeLoc TL) {
3684   TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3685   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3686   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3687   for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3688     TL.setArgLocInfo(i,
3689         Reader.GetTemplateArgumentLocInfo(F,
3690                                           TL.getTypePtr()->getArg(i).getKind(),
3691                                           Record, Idx));
3692 }
3693 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3694   TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3695   TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3696 }
3697 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3698   TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3699   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3700 }
3701 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3702   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3703 }
3704 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3705   TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3706   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3707   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3708 }
3709 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3710        DependentTemplateSpecializationTypeLoc TL) {
3711   TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3712   TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3713   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3714   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3715   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3716   for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3717     TL.setArgLocInfo(I,
3718         Reader.GetTemplateArgumentLocInfo(F,
3719                                           TL.getTypePtr()->getArg(I).getKind(),
3720                                           Record, Idx));
3721 }
3722 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3723   TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3724 }
3725 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3726   TL.setNameLoc(ReadSourceLocation(Record, Idx));
3727 }
3728 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3729   TL.setHasBaseTypeAsWritten(Record[Idx++]);
3730   TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3731   TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3732   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3733     TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3734 }
3735 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3736   TL.setStarLoc(ReadSourceLocation(Record, Idx));
3737 }
3738
3739 TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F,
3740                                              const RecordData &Record,
3741                                              unsigned &Idx) {
3742   QualType InfoTy = GetType(Record[Idx++]);
3743   if (InfoTy.isNull())
3744     return 0;
3745
3746   TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
3747   TypeLocReader TLR(*this, F, Record, Idx);
3748   for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
3749     TLR.Visit(TL);
3750   return TInfo;
3751 }
3752
3753 QualType ASTReader::GetType(TypeID ID) {
3754   unsigned FastQuals = ID & Qualifiers::FastMask;
3755   unsigned Index = ID >> Qualifiers::FastWidth;
3756
3757   if (Index < NUM_PREDEF_TYPE_IDS) {
3758     QualType T;
3759     switch ((PredefinedTypeIDs)Index) {
3760     case PREDEF_TYPE_NULL_ID: return QualType();
3761     case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3762     case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
3763
3764     case PREDEF_TYPE_CHAR_U_ID:
3765     case PREDEF_TYPE_CHAR_S_ID:
3766       // FIXME: Check that the signedness of CharTy is correct!
3767       T = Context->CharTy;
3768       break;
3769
3770     case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
3771     case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
3772     case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
3773     case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
3774     case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
3775     case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
3776     case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
3777     case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
3778     case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
3779     case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
3780     case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
3781     case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
3782     case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
3783     case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
3784     case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
3785     case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
3786     case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
3787     case PREDEF_TYPE_BOUND_MEMBER:  T = Context->BoundMemberTy;      break;
3788     case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
3789     case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
3790     case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
3791     case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
3792     case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
3793     case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
3794     case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
3795     case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
3796     }
3797
3798     assert(!T.isNull() && "Unknown predefined type");
3799     return T.withFastQualifiers(FastQuals);
3800   }
3801
3802   Index -= NUM_PREDEF_TYPE_IDS;
3803   assert(Index < TypesLoaded.size() && "Type index out-of-range");
3804   if (TypesLoaded[Index].isNull()) {
3805     TypesLoaded[Index] = ReadTypeRecord(Index);
3806     if (TypesLoaded[Index].isNull())
3807       return QualType();
3808
3809     TypesLoaded[Index]->setFromAST();
3810     TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID);
3811     if (DeserializationListener)
3812       DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
3813                                         TypesLoaded[Index]);
3814   }
3815
3816   return TypesLoaded[Index].withFastQualifiers(FastQuals);
3817 }
3818
3819 TypeID ASTReader::GetTypeID(QualType T) const {
3820   return MakeTypeID(T,
3821               std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
3822 }
3823
3824 TypeIdx ASTReader::GetTypeIdx(QualType T) const {
3825   if (T.isNull())
3826     return TypeIdx();
3827   assert(!T.getLocalFastQualifiers());
3828
3829   TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3830   // GetTypeIdx is mostly used for computing the hash of DeclarationNames and
3831   // comparing keys of ASTDeclContextNameLookupTable.
3832   // If the type didn't come from the AST file use a specially marked index
3833   // so that any hash/key comparison fail since no such index is stored
3834   // in a AST file.
3835   if (I == TypeIdxs.end())
3836     return TypeIdx(-1);
3837   return I->second;
3838 }
3839
3840 unsigned ASTReader::getTotalNumCXXBaseSpecifiers() const {
3841   unsigned Result = 0;
3842   for (unsigned I = 0, N = Chain.size(); I != N; ++I)
3843     Result += Chain[I]->LocalNumCXXBaseSpecifiers;
3844
3845   return Result;
3846 }
3847
3848 TemplateArgumentLocInfo
3849 ASTReader::GetTemplateArgumentLocInfo(PerFileData &F,
3850                                       TemplateArgument::ArgKind Kind,
3851                                       const RecordData &Record,
3852                                       unsigned &Index) {
3853   switch (Kind) {
3854   case TemplateArgument::Expression:
3855     return ReadExpr(F);
3856   case TemplateArgument::Type:
3857     return GetTypeSourceInfo(F, Record, Index);
3858   case TemplateArgument::Template: {
3859     NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3860                                                                      Index);
3861     SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3862     return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3863                                    SourceLocation());
3864   }
3865   case TemplateArgument::TemplateExpansion: {
3866     NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3867                                                                      Index);
3868     SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3869     SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
3870     return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3871                                    EllipsisLoc);
3872   }
3873   case TemplateArgument::Null:
3874   case TemplateArgument::Integral:
3875   case TemplateArgument::Declaration:
3876   case TemplateArgument::Pack:
3877     return TemplateArgumentLocInfo();
3878   }
3879   llvm_unreachable("unexpected template argument loc");
3880   return TemplateArgumentLocInfo();
3881 }
3882
3883 TemplateArgumentLoc
3884 ASTReader::ReadTemplateArgumentLoc(PerFileData &F,
3885                                    const RecordData &Record, unsigned &Index) {
3886   TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
3887
3888   if (Arg.getKind() == TemplateArgument::Expression) {
3889     if (Record[Index++]) // bool InfoHasSameExpr.
3890       return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
3891   }
3892   return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
3893                                                              Record, Index));
3894 }
3895
3896 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
3897   return GetDecl(ID);
3898 }
3899
3900 uint64_t
3901 ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
3902   if (ID == 0)
3903     return 0;
3904
3905   --ID;
3906   uint64_t Offset = 0;
3907   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3908     PerFileData &F = *Chain[N - I - 1];
3909
3910     if (ID < F.LocalNumCXXBaseSpecifiers)
3911       return Offset + F.CXXBaseSpecifiersOffsets[ID];
3912
3913     ID -= F.LocalNumCXXBaseSpecifiers;
3914     Offset += F.SizeInBits;
3915   }
3916
3917   assert(false && "CXXBaseSpecifiers not found");
3918   return 0;
3919 }
3920
3921 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
3922   // Figure out which AST file contains this offset.
3923   PerFileData *F = 0;
3924   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3925     if (Offset < Chain[N - I - 1]->SizeInBits) {
3926       F = Chain[N - I - 1];
3927       break;
3928     }
3929
3930     Offset -= Chain[N - I - 1]->SizeInBits;
3931   }
3932
3933   if (!F) {
3934     Error("Malformed AST file: C++ base specifiers at impossible offset");
3935     return 0;
3936   }
3937
3938   llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3939   SavedStreamPosition SavedPosition(Cursor);
3940   Cursor.JumpToBit(Offset);
3941   ReadingKindTracker ReadingKind(Read_Decl, *this);
3942   RecordData Record;
3943   unsigned Code = Cursor.ReadCode();
3944   unsigned RecCode = Cursor.ReadRecord(Code, Record);
3945   if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
3946     Error("Malformed AST file: missing C++ base specifiers");
3947     return 0;
3948   }
3949
3950   unsigned Idx = 0;
3951   unsigned NumBases = Record[Idx++];
3952   void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
3953   CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
3954   for (unsigned I = 0; I != NumBases; ++I)
3955     Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx);
3956   return Bases;
3957 }
3958
3959 TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
3960   if (!DeclsLoaded[0]) {
3961     ReadDeclRecord(0, 1);
3962     if (DeserializationListener)
3963       DeserializationListener->DeclRead(1, DeclsLoaded[0]);
3964   }
3965
3966   return cast<TranslationUnitDecl>(DeclsLoaded[0]);
3967 }
3968
3969 Decl *ASTReader::GetDecl(DeclID ID) {
3970   if (ID == 0)
3971     return 0;
3972
3973   if (ID > DeclsLoaded.size()) {
3974     Error("declaration ID out-of-range for AST file");
3975     return 0;
3976   }
3977
3978   unsigned Index = ID - 1;
3979   if (!DeclsLoaded[Index]) {
3980     ReadDeclRecord(Index, ID);
3981     if (DeserializationListener)
3982       DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
3983   }
3984
3985   return DeclsLoaded[Index];
3986 }
3987
3988 /// \brief Resolve the offset of a statement into a statement.
3989 ///
3990 /// This operation will read a new statement from the external
3991 /// source each time it is called, and is meant to be used via a
3992 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
3993 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
3994   // Switch case IDs are per Decl.
3995   ClearSwitchCaseIDs();
3996
3997   // Offset here is a global offset across the entire chain.
3998   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3999     PerFileData &F = *Chain[N - I - 1];
4000     if (Offset < F.SizeInBits) {
4001       // Since we know that this statement is part of a decl, make sure to use
4002       // the decl cursor to read it.
4003       F.DeclsCursor.JumpToBit(Offset);
4004       return ReadStmtFromStream(F);
4005     }
4006     Offset -= F.SizeInBits;
4007   }
4008   llvm_unreachable("Broken chain");
4009 }
4010
4011 ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4012                                          bool (*isKindWeWant)(Decl::Kind),
4013                                          llvm::SmallVectorImpl<Decl*> &Decls) {
4014   // There might be lexical decls in multiple parts of the chain, for the TU
4015   // at least.
4016   // DeclContextOffsets might reallocate as we load additional decls below,
4017   // so make a copy of the vector.
4018   DeclContextInfos Infos = DeclContextOffsets[DC];
4019   for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4020        I != E; ++I) {
4021     // IDs can be 0 if this context doesn't contain declarations.
4022     if (!I->LexicalDecls)
4023       continue;
4024
4025     // Load all of the declaration IDs
4026     for (const KindDeclIDPair *ID = I->LexicalDecls,
4027                               *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
4028       if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
4029         continue;
4030
4031       Decl *D = GetDecl(ID->second);
4032       assert(D && "Null decl in lexical decls");
4033       Decls.push_back(D);
4034     }
4035   }
4036
4037   ++NumLexicalDeclContextsRead;
4038   return ELR_Success;
4039 }
4040
4041 DeclContext::lookup_result
4042 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4043                                           DeclarationName Name) {
4044   assert(DC->hasExternalVisibleStorage() &&
4045          "DeclContext has no visible decls in storage");
4046   if (!Name)
4047     return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4048                                       DeclContext::lookup_iterator(0));
4049
4050   llvm::SmallVector<NamedDecl *, 64> Decls;
4051   // There might be visible decls in multiple parts of the chain, for the TU
4052   // and namespaces. For any given name, the last available results replace
4053   // all earlier ones. For this reason, we walk in reverse.
4054   DeclContextInfos &Infos = DeclContextOffsets[DC];
4055   for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
4056        I != E; ++I) {
4057     if (!I->NameLookupTableData)
4058       continue;
4059
4060     ASTDeclContextNameLookupTable *LookupTable =
4061         (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4062     ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
4063     if (Pos == LookupTable->end())
4064       continue;
4065
4066     ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4067     for (; Data.first != Data.second; ++Data.first)
4068       Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first)));
4069     break;
4070   }
4071
4072   ++NumVisibleDeclContextsRead;
4073
4074   SetExternalVisibleDeclsForName(DC, Name, Decls);
4075   return const_cast<DeclContext*>(DC)->lookup(Name);
4076 }
4077
4078 void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
4079   assert(DC->hasExternalVisibleStorage() &&
4080          "DeclContext has no visible decls in storage");
4081
4082   llvm::SmallVector<NamedDecl *, 64> Decls;
4083   // There might be visible decls in multiple parts of the chain, for the TU
4084   // and namespaces.
4085   DeclContextInfos &Infos = DeclContextOffsets[DC];
4086   for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4087        I != E; ++I) {
4088     if (!I->NameLookupTableData)
4089       continue;
4090
4091     ASTDeclContextNameLookupTable *LookupTable =
4092         (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4093     for (ASTDeclContextNameLookupTable::item_iterator
4094            ItemI = LookupTable->item_begin(),
4095            ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
4096       ASTDeclContextNameLookupTable::item_iterator::value_type Val
4097           = *ItemI;
4098       ASTDeclContextNameLookupTrait::data_type Data = Val.second;
4099       Decls.clear();
4100       for (; Data.first != Data.second; ++Data.first)
4101         Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first)));
4102       MaterializeVisibleDeclsForName(DC, Val.first, Decls);
4103     }
4104   }
4105 }
4106
4107 void ASTReader::PassInterestingDeclsToConsumer() {
4108   assert(Consumer);
4109   while (!InterestingDecls.empty()) {
4110     DeclGroupRef DG(InterestingDecls.front());
4111     InterestingDecls.pop_front();
4112     Consumer->HandleInterestingDecl(DG);
4113   }
4114 }
4115
4116 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4117   this->Consumer = Consumer;
4118
4119   if (!Consumer)
4120     return;
4121
4122   for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4123     // Force deserialization of this decl, which will cause it to be queued for
4124     // passing to the consumer.
4125     GetDecl(ExternalDefinitions[I]);
4126   }
4127
4128   PassInterestingDeclsToConsumer();
4129 }
4130
4131 void ASTReader::PrintStats() {
4132   std::fprintf(stderr, "*** AST File Statistics:\n");
4133
4134   unsigned NumTypesLoaded
4135     = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4136                                       QualType());
4137   unsigned NumDeclsLoaded
4138     = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4139                                       (Decl *)0);
4140   unsigned NumIdentifiersLoaded
4141     = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4142                                             IdentifiersLoaded.end(),
4143                                             (IdentifierInfo *)0);
4144   unsigned NumSelectorsLoaded
4145     = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4146                                           SelectorsLoaded.end(),
4147                                           Selector());
4148
4149   std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4150   std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4151   if (TotalNumSLocEntries)
4152     std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4153                  NumSLocEntriesRead, TotalNumSLocEntries,
4154                  ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4155   if (!TypesLoaded.empty())
4156     std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4157                  NumTypesLoaded, (unsigned)TypesLoaded.size(),
4158                  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4159   if (!DeclsLoaded.empty())
4160     std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4161                  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4162                  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4163   if (!IdentifiersLoaded.empty())
4164     std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4165                  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4166                  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4167   if (!SelectorsLoaded.empty())
4168     std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4169                  NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4170                  ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4171   if (TotalNumStatements)
4172     std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4173                  NumStatementsRead, TotalNumStatements,
4174                  ((float)NumStatementsRead/TotalNumStatements * 100));
4175   if (TotalNumMacros)
4176     std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4177                  NumMacrosRead, TotalNumMacros,
4178                  ((float)NumMacrosRead/TotalNumMacros * 100));
4179   if (TotalLexicalDeclContexts)
4180     std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4181                  NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4182                  ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4183                   * 100));
4184   if (TotalVisibleDeclContexts)
4185     std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4186                  NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4187                  ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4188                   * 100));
4189   if (TotalNumMethodPoolEntries) {
4190     std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4191                  NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4192                  ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4193                   * 100));
4194     std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4195   }
4196   std::fprintf(stderr, "\n");
4197 }
4198
4199 /// Return the amount of memory used by memory buffers, breaking down
4200 /// by heap-backed versus mmap'ed memory.
4201 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4202   for (unsigned i = 0, e = Chain.size(); i != e; ++i)
4203     if (llvm::MemoryBuffer *buf = Chain[i]->Buffer.get()) {
4204       size_t bytes = buf->getBufferSize();
4205       switch (buf->getBufferKind()) {
4206         case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4207           sizes.malloc_bytes += bytes;
4208           break;
4209         case llvm::MemoryBuffer::MemoryBuffer_MMap:
4210           sizes.mmap_bytes += bytes;
4211           break;
4212       }
4213     }
4214 }
4215
4216 void ASTReader::InitializeSema(Sema &S) {
4217   SemaObj = &S;
4218   S.ExternalSource = this;
4219
4220   // Makes sure any declarations that were deserialized "too early"
4221   // still get added to the identifier's declaration chains.
4222   for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4223     if (SemaObj->TUScope)
4224       SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4225
4226     SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4227   }
4228   PreloadedDecls.clear();
4229
4230   // If there were any tentative definitions, deserialize them and add
4231   // them to Sema's list of tentative definitions.
4232   for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4233     VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I]));
4234     SemaObj->TentativeDefinitions.push_back(Var);
4235   }
4236
4237   // If there were any unused file scoped decls, deserialize them and add to
4238   // Sema's list of unused file scoped decls.
4239   for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4240     DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4241     SemaObj->UnusedFileScopedDecls.push_back(D);
4242   }
4243
4244   // If there were any delegating constructors, add them to Sema's list
4245   for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4246     CXXConstructorDecl *D
4247      = cast<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4248     SemaObj->DelegatingCtorDecls.push_back(D);
4249   }
4250
4251   // If there were any locally-scoped external declarations,
4252   // deserialize them and add them to Sema's table of locally-scoped
4253   // external declarations.
4254   for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4255     NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4256     SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D;
4257   }
4258
4259   // If there were any ext_vector type declarations, deserialize them
4260   // and add them to Sema's vector of such declarations.
4261   for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I)
4262     SemaObj->ExtVectorDecls.push_back(
4263                              cast<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])));
4264
4265   // FIXME: Do VTable uses and dynamic classes deserialize too much ?
4266   // Can we cut them down before writing them ?
4267
4268   // If there were any dynamic classes declarations, deserialize them
4269   // and add them to Sema's vector of such declarations.
4270   for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I)
4271     SemaObj->DynamicClasses.push_back(
4272                                cast<CXXRecordDecl>(GetDecl(DynamicClasses[I])));
4273
4274   // Load the offsets of the declarations that Sema references.
4275   // They will be lazily deserialized when needed.
4276   if (!SemaDeclRefs.empty()) {
4277     assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4278     SemaObj->StdNamespace = SemaDeclRefs[0];
4279     SemaObj->StdBadAlloc = SemaDeclRefs[1];
4280   }
4281
4282   for (PerFileData *F = FirstInSource; F; F = F->NextInSource) {
4283
4284     // If there are @selector references added them to its pool. This is for
4285     // implementation of -Wselector.
4286     if (!F->ReferencedSelectorsData.empty()) {
4287       unsigned int DataSize = F->ReferencedSelectorsData.size()-1;
4288       unsigned I = 0;
4289       while (I < DataSize) {
4290         Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]);
4291         SourceLocation SelLoc = ReadSourceLocation(
4292                                     *F, F->ReferencedSelectorsData, I);
4293         SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc));
4294       }
4295     }
4296   }
4297
4298   // The special data sets below always come from the most recent PCH,
4299   // which is at the front of the chain.
4300   PerFileData &F = *Chain.front();
4301
4302   // If there were any pending implicit instantiations, deserialize them
4303   // and add them to Sema's queue of such instantiations.
4304   assert(F.PendingInstantiations.size() % 2 == 0 &&
4305          "Expected pairs of entries");
4306   for (unsigned Idx = 0, N = F.PendingInstantiations.size(); Idx < N;) {
4307     ValueDecl *D=cast<ValueDecl>(GetDecl(F.PendingInstantiations[Idx++]));
4308     SourceLocation Loc = ReadSourceLocation(F, F.PendingInstantiations,Idx);
4309     SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc));
4310   }
4311
4312   // If there were any weak undeclared identifiers, deserialize them and add to
4313   // Sema's list of weak undeclared identifiers.
4314   if (!WeakUndeclaredIdentifiers.empty()) {
4315     unsigned Idx = 0;
4316     for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) {
4317       IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4318       IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4319       SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx);
4320       bool Used = WeakUndeclaredIdentifiers[Idx++];
4321       Sema::WeakInfo WI(AliasId, Loc);
4322       WI.setUsed(Used);
4323       SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI));
4324     }
4325   }
4326
4327   // If there were any VTable uses, deserialize the information and add it
4328   // to Sema's vector and map of VTable uses.
4329   if (!VTableUses.empty()) {
4330     unsigned Idx = 0;
4331     for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) {
4332       CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4333       SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx);
4334       bool DefinitionRequired = VTableUses[Idx++];
4335       SemaObj->VTableUses.push_back(std::make_pair(Class, Loc));
4336       SemaObj->VTablesUsed[Class] = DefinitionRequired;
4337     }
4338   }
4339
4340   if (!FPPragmaOptions.empty()) {
4341     assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4342     SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4343   }
4344
4345   if (!OpenCLExtensions.empty()) {
4346     unsigned I = 0;
4347 #define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4348 #include "clang/Basic/OpenCLExtensions.def"
4349
4350     assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4351   }
4352 }
4353
4354 IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4355   // Try to find this name within our on-disk hash tables. We start with the
4356   // most recent one, since that one contains the most up-to-date info.
4357   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4358     ASTIdentifierLookupTable *IdTable
4359         = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable;
4360     if (!IdTable)
4361       continue;
4362     std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4363     ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4364     if (Pos == IdTable->end())
4365       continue;
4366
4367     // Dereferencing the iterator has the effect of building the
4368     // IdentifierInfo node and populating it with the various
4369     // declarations it needs.
4370     return *Pos;
4371   }
4372   return 0;
4373 }
4374
4375 namespace clang {
4376   /// \brief An identifier-lookup iterator that enumerates all of the
4377   /// identifiers stored within a set of AST files.
4378   class ASTIdentifierIterator : public IdentifierIterator {
4379     /// \brief The AST reader whose identifiers are being enumerated.
4380     const ASTReader &Reader;
4381
4382     /// \brief The current index into the chain of AST files stored in
4383     /// the AST reader.
4384     unsigned Index;
4385
4386     /// \brief The current position within the identifier lookup table
4387     /// of the current AST file.
4388     ASTIdentifierLookupTable::key_iterator Current;
4389
4390     /// \brief The end position within the identifier lookup table of
4391     /// the current AST file.
4392     ASTIdentifierLookupTable::key_iterator End;
4393
4394   public:
4395     explicit ASTIdentifierIterator(const ASTReader &Reader);
4396
4397     virtual llvm::StringRef Next();
4398   };
4399 }
4400
4401 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4402   : Reader(Reader), Index(Reader.Chain.size() - 1) {
4403   ASTIdentifierLookupTable *IdTable
4404     = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable;
4405   Current = IdTable->key_begin();
4406   End = IdTable->key_end();
4407 }
4408
4409 llvm::StringRef ASTIdentifierIterator::Next() {
4410   while (Current == End) {
4411     // If we have exhausted all of our AST files, we're done.
4412     if (Index == 0)
4413       return llvm::StringRef();
4414
4415     --Index;
4416     ASTIdentifierLookupTable *IdTable
4417       = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable;
4418     Current = IdTable->key_begin();
4419     End = IdTable->key_end();
4420   }
4421
4422   // We have any identifiers remaining in the current AST file; return
4423   // the next one.
4424   std::pair<const char*, unsigned> Key = *Current;
4425   ++Current;
4426   return llvm::StringRef(Key.first, Key.second);
4427 }
4428
4429 IdentifierIterator *ASTReader::getIdentifiers() const {
4430   return new ASTIdentifierIterator(*this);
4431 }
4432
4433 std::pair<ObjCMethodList, ObjCMethodList>
4434 ASTReader::ReadMethodPool(Selector Sel) {
4435   // Find this selector in a hash table. We want to find the most recent entry.
4436   for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4437     PerFileData &F = *Chain[I];
4438     if (!F.SelectorLookupTable)
4439       continue;
4440
4441     ASTSelectorLookupTable *PoolTable
4442       = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4443     ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4444     if (Pos != PoolTable->end()) {
4445       ++NumSelectorsRead;
4446       // FIXME: Not quite happy with the statistics here. We probably should
4447       // disable this tracking when called via LoadSelector.
4448       // Also, should entries without methods count as misses?
4449       ++NumMethodPoolEntriesRead;
4450       ASTSelectorLookupTrait::data_type Data = *Pos;
4451       if (DeserializationListener)
4452         DeserializationListener->SelectorRead(Data.ID, Sel);
4453       return std::make_pair(Data.Instance, Data.Factory);
4454     }
4455   }
4456
4457   ++NumMethodPoolMisses;
4458   return std::pair<ObjCMethodList, ObjCMethodList>();
4459 }
4460
4461 void ASTReader::ReadKnownNamespaces(
4462                           llvm::SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4463   Namespaces.clear();
4464
4465   for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4466     if (NamespaceDecl *Namespace
4467                 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4468       Namespaces.push_back(Namespace);
4469   }
4470 }
4471
4472 void ASTReader::LoadSelector(Selector Sel) {
4473   // It would be complicated to avoid reading the methods anyway. So don't.
4474   ReadMethodPool(Sel);
4475 }
4476
4477 void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) {
4478   assert(ID && "Non-zero identifier ID required");
4479   assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4480   IdentifiersLoaded[ID - 1] = II;
4481   if (DeserializationListener)
4482     DeserializationListener->IdentifierRead(ID, II);
4483 }
4484
4485 /// \brief Set the globally-visible declarations associated with the given
4486 /// identifier.
4487 ///
4488 /// If the AST reader is currently in a state where the given declaration IDs
4489 /// cannot safely be resolved, they are queued until it is safe to resolve
4490 /// them.
4491 ///
4492 /// \param II an IdentifierInfo that refers to one or more globally-visible
4493 /// declarations.
4494 ///
4495 /// \param DeclIDs the set of declaration IDs with the name @p II that are
4496 /// visible at global scope.
4497 ///
4498 /// \param Nonrecursive should be true to indicate that the caller knows that
4499 /// this call is non-recursive, and therefore the globally-visible declarations
4500 /// will not be placed onto the pending queue.
4501 void
4502 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4503                               const llvm::SmallVectorImpl<uint32_t> &DeclIDs,
4504                                    bool Nonrecursive) {
4505   if (NumCurrentElementsDeserializing && !Nonrecursive) {
4506     PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4507     PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4508     PII.II = II;
4509     PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4510     return;
4511   }
4512
4513   for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4514     NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4515     if (SemaObj) {
4516       if (SemaObj->TUScope) {
4517         // Introduce this declaration into the translation-unit scope
4518         // and add it to the declaration chain for this identifier, so
4519         // that (unqualified) name lookup will find it.
4520         SemaObj->TUScope->AddDecl(D);
4521       }
4522       SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4523     } else {
4524       // Queue this declaration so that it will be added to the
4525       // translation unit scope and identifier's declaration chain
4526       // once a Sema object is known.
4527       PreloadedDecls.push_back(D);
4528     }
4529   }
4530 }
4531
4532 IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) {
4533   if (ID == 0)
4534     return 0;
4535
4536   if (IdentifiersLoaded.empty()) {
4537     Error("no identifier table in AST file");
4538     return 0;
4539   }
4540
4541   assert(PP && "Forgot to set Preprocessor ?");
4542   ID -= 1;
4543   if (!IdentifiersLoaded[ID]) {
4544     unsigned Index = ID;
4545     const char *Str = 0;
4546     for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4547       PerFileData *F = Chain[N - I - 1];
4548       if (Index < F->LocalNumIdentifiers) {
4549          uint32_t Offset = F->IdentifierOffsets[Index];
4550          Str = F->IdentifierTableData + Offset;
4551          break;
4552       }
4553       Index -= F->LocalNumIdentifiers;
4554     }
4555     assert(Str && "Broken Chain");
4556
4557     // All of the strings in the AST file are preceded by a 16-bit length.
4558     // Extract that 16-bit length to avoid having to execute strlen().
4559     // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4560     //  unsigned integers.  This is important to avoid integer overflow when
4561     //  we cast them to 'unsigned'.
4562     const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4563     unsigned StrLen = (((unsigned) StrLenPtr[0])
4564                        | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4565     IdentifiersLoaded[ID]
4566       = &PP->getIdentifierTable().get(llvm::StringRef(Str, StrLen));
4567     if (DeserializationListener)
4568       DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4569   }
4570
4571   return IdentifiersLoaded[ID];
4572 }
4573
4574 bool ASTReader::ReadSLocEntry(unsigned ID) {
4575   return ReadSLocEntryRecord(ID) != Success;
4576 }
4577
4578 Selector ASTReader::DecodeSelector(unsigned ID) {
4579   if (ID == 0)
4580     return Selector();
4581
4582   if (ID > SelectorsLoaded.size()) {
4583     Error("selector ID out of range in AST file");
4584     return Selector();
4585   }
4586
4587   if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4588     // Load this selector from the selector table.
4589     unsigned Idx = ID - 1;
4590     for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4591       PerFileData &F = *Chain[N - I - 1];
4592       if (Idx < F.LocalNumSelectors) {
4593         ASTSelectorLookupTrait Trait(*this);
4594         SelectorsLoaded[ID - 1] =
4595            Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0);
4596         if (DeserializationListener)
4597           DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4598         break;
4599       }
4600       Idx -= F.LocalNumSelectors;
4601     }
4602   }
4603
4604   return SelectorsLoaded[ID - 1];
4605 }
4606
4607 Selector ASTReader::GetExternalSelector(uint32_t ID) {
4608   return DecodeSelector(ID);
4609 }
4610
4611 uint32_t ASTReader::GetNumExternalSelectors() {
4612   // ID 0 (the null selector) is considered an external selector.
4613   return getTotalNumSelectors() + 1;
4614 }
4615
4616 DeclarationName
4617 ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) {
4618   DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4619   switch (Kind) {
4620   case DeclarationName::Identifier:
4621     return DeclarationName(GetIdentifierInfo(Record, Idx));
4622
4623   case DeclarationName::ObjCZeroArgSelector:
4624   case DeclarationName::ObjCOneArgSelector:
4625   case DeclarationName::ObjCMultiArgSelector:
4626     return DeclarationName(GetSelector(Record, Idx));
4627
4628   case DeclarationName::CXXConstructorName:
4629     return Context->DeclarationNames.getCXXConstructorName(
4630                           Context->getCanonicalType(GetType(Record[Idx++])));
4631
4632   case DeclarationName::CXXDestructorName:
4633     return Context->DeclarationNames.getCXXDestructorName(
4634                           Context->getCanonicalType(GetType(Record[Idx++])));
4635
4636   case DeclarationName::CXXConversionFunctionName:
4637     return Context->DeclarationNames.getCXXConversionFunctionName(
4638                           Context->getCanonicalType(GetType(Record[Idx++])));
4639
4640   case DeclarationName::CXXOperatorName:
4641     return Context->DeclarationNames.getCXXOperatorName(
4642                                        (OverloadedOperatorKind)Record[Idx++]);
4643
4644   case DeclarationName::CXXLiteralOperatorName:
4645     return Context->DeclarationNames.getCXXLiteralOperatorName(
4646                                        GetIdentifierInfo(Record, Idx));
4647
4648   case DeclarationName::CXXUsingDirective:
4649     return DeclarationName::getUsingDirectiveName();
4650   }
4651
4652   // Required to silence GCC warning
4653   return DeclarationName();
4654 }
4655
4656 void ASTReader::ReadDeclarationNameLoc(PerFileData &F,
4657                                        DeclarationNameLoc &DNLoc,
4658                                        DeclarationName Name,
4659                                       const RecordData &Record, unsigned &Idx) {
4660   switch (Name.getNameKind()) {
4661   case DeclarationName::CXXConstructorName:
4662   case DeclarationName::CXXDestructorName:
4663   case DeclarationName::CXXConversionFunctionName:
4664     DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4665     break;
4666
4667   case DeclarationName::CXXOperatorName:
4668     DNLoc.CXXOperatorName.BeginOpNameLoc
4669         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4670     DNLoc.CXXOperatorName.EndOpNameLoc
4671         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4672     break;
4673
4674   case DeclarationName::CXXLiteralOperatorName:
4675     DNLoc.CXXLiteralOperatorName.OpNameLoc
4676         = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4677     break;
4678
4679   case DeclarationName::Identifier:
4680   case DeclarationName::ObjCZeroArgSelector:
4681   case DeclarationName::ObjCOneArgSelector:
4682   case DeclarationName::ObjCMultiArgSelector:
4683   case DeclarationName::CXXUsingDirective:
4684     break;
4685   }
4686 }
4687
4688 void ASTReader::ReadDeclarationNameInfo(PerFileData &F,
4689                                         DeclarationNameInfo &NameInfo,
4690                                       const RecordData &Record, unsigned &Idx) {
4691   NameInfo.setName(ReadDeclarationName(Record, Idx));
4692   NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4693   DeclarationNameLoc DNLoc;
4694   ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4695   NameInfo.setInfo(DNLoc);
4696 }
4697
4698 void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info,
4699                                   const RecordData &Record, unsigned &Idx) {
4700   Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
4701   unsigned NumTPLists = Record[Idx++];
4702   Info.NumTemplParamLists = NumTPLists;
4703   if (NumTPLists) {
4704     Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4705     for (unsigned i=0; i != NumTPLists; ++i)
4706       Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4707   }
4708 }
4709
4710 TemplateName
4711 ASTReader::ReadTemplateName(PerFileData &F, const RecordData &Record,
4712                             unsigned &Idx) {
4713   TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
4714   switch (Kind) {
4715   case TemplateName::Template:
4716     return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++])));
4717
4718   case TemplateName::OverloadedTemplate: {
4719     unsigned size = Record[Idx++];
4720     UnresolvedSet<8> Decls;
4721     while (size--)
4722       Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++])));
4723
4724     return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4725   }
4726
4727   case TemplateName::QualifiedTemplate: {
4728     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
4729     bool hasTemplKeyword = Record[Idx++];
4730     TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++]));
4731     return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4732   }
4733
4734   case TemplateName::DependentTemplate: {
4735     NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
4736     if (Record[Idx++])  // isIdentifier
4737       return Context->getDependentTemplateName(NNS,
4738                                                GetIdentifierInfo(Record, Idx));
4739     return Context->getDependentTemplateName(NNS,
4740                                          (OverloadedOperatorKind)Record[Idx++]);
4741   }
4742
4743   case TemplateName::SubstTemplateTemplateParm: {
4744     TemplateTemplateParmDecl *param
4745       = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++]));
4746     if (!param) return TemplateName();
4747     TemplateName replacement = ReadTemplateName(F, Record, Idx);
4748     return Context->getSubstTemplateTemplateParm(param, replacement);
4749   }
4750
4751   case TemplateName::SubstTemplateTemplateParmPack: {
4752     TemplateTemplateParmDecl *Param
4753       = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++]));
4754     if (!Param)
4755       return TemplateName();
4756
4757     TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4758     if (ArgPack.getKind() != TemplateArgument::Pack)
4759       return TemplateName();
4760
4761     return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4762   }
4763   }
4764
4765   assert(0 && "Unhandled template name kind!");
4766   return TemplateName();
4767 }
4768
4769 TemplateArgument
4770 ASTReader::ReadTemplateArgument(PerFileData &F,
4771                                 const RecordData &Record, unsigned &Idx) {
4772   TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4773   switch (Kind) {
4774   case TemplateArgument::Null:
4775     return TemplateArgument();
4776   case TemplateArgument::Type:
4777     return TemplateArgument(GetType(Record[Idx++]));
4778   case TemplateArgument::Declaration:
4779     return TemplateArgument(GetDecl(Record[Idx++]));
4780   case TemplateArgument::Integral: {
4781     llvm::APSInt Value = ReadAPSInt(Record, Idx);
4782     QualType T = GetType(Record[Idx++]);
4783     return TemplateArgument(Value, T);
4784   }
4785   case TemplateArgument::Template:
4786     return TemplateArgument(ReadTemplateName(F, Record, Idx));
4787   case TemplateArgument::TemplateExpansion: {
4788     TemplateName Name = ReadTemplateName(F, Record, Idx);
4789     llvm::Optional<unsigned> NumTemplateExpansions;
4790     if (unsigned NumExpansions = Record[Idx++])
4791       NumTemplateExpansions = NumExpansions - 1;
4792     return TemplateArgument(Name, NumTemplateExpansions);
4793   }
4794   case TemplateArgument::Expression:
4795     return TemplateArgument(ReadExpr(F));
4796   case TemplateArgument::Pack: {
4797     unsigned NumArgs = Record[Idx++];
4798     TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
4799     for (unsigned I = 0; I != NumArgs; ++I)
4800       Args[I] = ReadTemplateArgument(F, Record, Idx);
4801     return TemplateArgument(Args, NumArgs);
4802   }
4803   }
4804
4805   assert(0 && "Unhandled template argument kind!");
4806   return TemplateArgument();
4807 }
4808
4809 TemplateParameterList *
4810 ASTReader::ReadTemplateParameterList(PerFileData &F,
4811                                      const RecordData &Record, unsigned &Idx) {
4812   SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
4813   SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
4814   SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
4815
4816   unsigned NumParams = Record[Idx++];
4817   llvm::SmallVector<NamedDecl *, 16> Params;
4818   Params.reserve(NumParams);
4819   while (NumParams--)
4820     Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++])));
4821
4822   TemplateParameterList* TemplateParams =
4823     TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
4824                                   Params.data(), Params.size(), RAngleLoc);
4825   return TemplateParams;
4826 }
4827
4828 void
4829 ASTReader::
4830 ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs,
4831                          PerFileData &F, const RecordData &Record,
4832                          unsigned &Idx) {
4833   unsigned NumTemplateArgs = Record[Idx++];
4834   TemplArgs.reserve(NumTemplateArgs);
4835   while (NumTemplateArgs--)
4836     TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
4837 }
4838
4839 /// \brief Read a UnresolvedSet structure.
4840 void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set,
4841                                   const RecordData &Record, unsigned &Idx) {
4842   unsigned NumDecls = Record[Idx++];
4843   while (NumDecls--) {
4844     NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++]));
4845     AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
4846     Set.addDecl(D, AS);
4847   }
4848 }
4849
4850 CXXBaseSpecifier
4851 ASTReader::ReadCXXBaseSpecifier(PerFileData &F,
4852                                 const RecordData &Record, unsigned &Idx) {
4853   bool isVirtual = static_cast<bool>(Record[Idx++]);
4854   bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
4855   AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
4856   bool inheritConstructors = static_cast<bool>(Record[Idx++]);
4857   TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
4858   SourceRange Range = ReadSourceRange(F, Record, Idx);
4859   SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
4860   CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
4861                           EllipsisLoc);
4862   Result.setInheritConstructors(inheritConstructors);
4863   return Result;
4864 }
4865
4866 std::pair<CXXCtorInitializer **, unsigned>
4867 ASTReader::ReadCXXCtorInitializers(PerFileData &F, const RecordData &Record,
4868                                    unsigned &Idx) {
4869   CXXCtorInitializer **CtorInitializers = 0;
4870   unsigned NumInitializers = Record[Idx++];
4871   if (NumInitializers) {
4872     ASTContext &C = *getContext();
4873
4874     CtorInitializers
4875         = new (C) CXXCtorInitializer*[NumInitializers];
4876     for (unsigned i=0; i != NumInitializers; ++i) {
4877       TypeSourceInfo *BaseClassInfo = 0;
4878       bool IsBaseVirtual = false;
4879       FieldDecl *Member = 0;
4880       IndirectFieldDecl *IndirectMember = 0;
4881       CXXConstructorDecl *Target = 0;
4882
4883       CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
4884       switch (Type) {
4885        case CTOR_INITIALIZER_BASE:
4886         BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
4887         IsBaseVirtual = Record[Idx++];
4888         break;
4889
4890        case CTOR_INITIALIZER_DELEGATING:
4891         Target = cast<CXXConstructorDecl>(GetDecl(Record[Idx++]));
4892         break;
4893
4894        case CTOR_INITIALIZER_MEMBER:
4895         Member = cast<FieldDecl>(GetDecl(Record[Idx++]));
4896         break;
4897
4898        case CTOR_INITIALIZER_INDIRECT_MEMBER:
4899         IndirectMember = cast<IndirectFieldDecl>(GetDecl(Record[Idx++]));
4900         break;
4901       }
4902
4903       SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
4904       Expr *Init = ReadExpr(F);
4905       SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
4906       SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
4907       bool IsWritten = Record[Idx++];
4908       unsigned SourceOrderOrNumArrayIndices;
4909       llvm::SmallVector<VarDecl *, 8> Indices;
4910       if (IsWritten) {
4911         SourceOrderOrNumArrayIndices = Record[Idx++];
4912       } else {
4913         SourceOrderOrNumArrayIndices = Record[Idx++];
4914         Indices.reserve(SourceOrderOrNumArrayIndices);
4915         for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
4916           Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++])));
4917       }
4918
4919       CXXCtorInitializer *BOMInit;
4920       if (Type == CTOR_INITIALIZER_BASE) {
4921         BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
4922                                              LParenLoc, Init, RParenLoc,
4923                                              MemberOrEllipsisLoc);
4924       } else if (Type == CTOR_INITIALIZER_DELEGATING) {
4925         BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
4926                                              Target, Init, RParenLoc);
4927       } else if (IsWritten) {
4928         if (Member)
4929           BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
4930                                                LParenLoc, Init, RParenLoc);
4931         else
4932           BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
4933                                                MemberOrEllipsisLoc, LParenLoc,
4934                                                Init, RParenLoc);
4935       } else {
4936         BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
4937                                              LParenLoc, Init, RParenLoc,
4938                                              Indices.data(), Indices.size());
4939       }
4940
4941       if (IsWritten)
4942         BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
4943       CtorInitializers[i] = BOMInit;
4944     }
4945   }
4946
4947   return std::make_pair(CtorInitializers, NumInitializers);
4948 }
4949
4950 NestedNameSpecifier *
4951 ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) {
4952   unsigned N = Record[Idx++];
4953   NestedNameSpecifier *NNS = 0, *Prev = 0;
4954   for (unsigned I = 0; I != N; ++I) {
4955     NestedNameSpecifier::SpecifierKind Kind
4956       = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
4957     switch (Kind) {
4958     case NestedNameSpecifier::Identifier: {
4959       IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
4960       NNS = NestedNameSpecifier::Create(*Context, Prev, II);
4961       break;
4962     }
4963
4964     case NestedNameSpecifier::Namespace: {
4965       NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
4966       NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
4967       break;
4968     }
4969
4970     case NestedNameSpecifier::NamespaceAlias: {
4971       NamespaceAliasDecl *Alias
4972         = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++]));
4973       NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
4974       break;
4975     }
4976
4977     case NestedNameSpecifier::TypeSpec:
4978     case NestedNameSpecifier::TypeSpecWithTemplate: {
4979       const Type *T = GetType(Record[Idx++]).getTypePtrOrNull();
4980       if (!T)
4981         return 0;
4982
4983       bool Template = Record[Idx++];
4984       NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
4985       break;
4986     }
4987
4988     case NestedNameSpecifier::Global: {
4989       NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
4990       // No associated value, and there can't be a prefix.
4991       break;
4992     }
4993     }
4994     Prev = NNS;
4995   }
4996   return NNS;
4997 }
4998
4999 NestedNameSpecifierLoc
5000 ASTReader::ReadNestedNameSpecifierLoc(PerFileData &F, const RecordData &Record,
5001                                       unsigned &Idx) {
5002   unsigned N = Record[Idx++];
5003   NestedNameSpecifierLocBuilder Builder;
5004   for (unsigned I = 0; I != N; ++I) {
5005     NestedNameSpecifier::SpecifierKind Kind
5006       = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5007     switch (Kind) {
5008     case NestedNameSpecifier::Identifier: {
5009       IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
5010       SourceRange Range = ReadSourceRange(F, Record, Idx);
5011       Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5012       break;
5013     }
5014
5015     case NestedNameSpecifier::Namespace: {
5016       NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
5017       SourceRange Range = ReadSourceRange(F, Record, Idx);
5018       Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5019       break;
5020     }
5021
5022     case NestedNameSpecifier::NamespaceAlias: {
5023       NamespaceAliasDecl *Alias
5024         = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++]));
5025       SourceRange Range = ReadSourceRange(F, Record, Idx);
5026       Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5027       break;
5028     }
5029
5030     case NestedNameSpecifier::TypeSpec:
5031     case NestedNameSpecifier::TypeSpecWithTemplate: {
5032       bool Template = Record[Idx++];
5033       TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5034       if (!T)
5035         return NestedNameSpecifierLoc();
5036       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5037
5038       // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5039       Builder.Extend(*Context,
5040                      Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5041                      T->getTypeLoc(), ColonColonLoc);
5042       break;
5043     }
5044
5045     case NestedNameSpecifier::Global: {
5046       SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5047       Builder.MakeGlobal(*Context, ColonColonLoc);
5048       break;
5049     }
5050     }
5051   }
5052
5053   return Builder.getWithLocInContext(*Context);
5054 }
5055
5056 SourceRange
5057 ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record,
5058                            unsigned &Idx) {
5059   SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5060   SourceLocation end = ReadSourceLocation(F, Record, Idx);
5061   return SourceRange(beg, end);
5062 }
5063
5064 /// \brief Read an integral value
5065 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5066   unsigned BitWidth = Record[Idx++];
5067   unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5068   llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5069   Idx += NumWords;
5070   return Result;
5071 }
5072
5073 /// \brief Read a signed integral value
5074 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5075   bool isUnsigned = Record[Idx++];
5076   return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5077 }
5078
5079 /// \brief Read a floating-point value
5080 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5081   return llvm::APFloat(ReadAPInt(Record, Idx));
5082 }
5083
5084 // \brief Read a string
5085 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5086   unsigned Len = Record[Idx++];
5087   std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5088   Idx += Len;
5089   return Result;
5090 }
5091
5092 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5093                                          unsigned &Idx) {
5094   unsigned Major = Record[Idx++];
5095   unsigned Minor = Record[Idx++];
5096   unsigned Subminor = Record[Idx++];
5097   if (Minor == 0)
5098     return VersionTuple(Major);
5099   if (Subminor == 0)
5100     return VersionTuple(Major, Minor - 1);
5101   return VersionTuple(Major, Minor - 1, Subminor - 1);
5102 }
5103
5104 CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record,
5105                                           unsigned &Idx) {
5106   CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++]));
5107   return CXXTemporary::Create(*Context, Decl);
5108 }
5109
5110 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5111   return Diag(SourceLocation(), DiagID);
5112 }
5113
5114 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5115   return Diags.Report(Loc, DiagID);
5116 }
5117
5118 /// \brief Retrieve the identifier table associated with the
5119 /// preprocessor.
5120 IdentifierTable &ASTReader::getIdentifierTable() {
5121   assert(PP && "Forgot to set Preprocessor ?");
5122   return PP->getIdentifierTable();
5123 }
5124
5125 /// \brief Record that the given ID maps to the given switch-case
5126 /// statement.
5127 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5128   assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5129   SwitchCaseStmts[ID] = SC;
5130 }
5131
5132 /// \brief Retrieve the switch-case statement with the given ID.
5133 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5134   assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5135   return SwitchCaseStmts[ID];
5136 }
5137
5138 void ASTReader::ClearSwitchCaseIDs() {
5139   SwitchCaseStmts.clear();
5140 }
5141
5142 void ASTReader::FinishedDeserializing() {
5143   assert(NumCurrentElementsDeserializing &&
5144          "FinishedDeserializing not paired with StartedDeserializing");
5145   if (NumCurrentElementsDeserializing == 1) {
5146     // If any identifiers with corresponding top-level declarations have
5147     // been loaded, load those declarations now.
5148     while (!PendingIdentifierInfos.empty()) {
5149       SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5150                               PendingIdentifierInfos.front().DeclIDs, true);
5151       PendingIdentifierInfos.pop_front();
5152     }
5153
5154     // Ready to load previous declarations of Decls that were delayed.
5155     while (!PendingPreviousDecls.empty()) {
5156       loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5157                                 PendingPreviousDecls.front().second);
5158       PendingPreviousDecls.pop_front();
5159     }
5160
5161     // We are not in recursive loading, so it's safe to pass the "interesting"
5162     // decls to the consumer.
5163     if (Consumer)
5164       PassInterestingDeclsToConsumer();
5165
5166     assert(PendingForwardRefs.size() == 0 &&
5167            "Some forward refs did not get linked to the definition!");
5168   }
5169   --NumCurrentElementsDeserializing;
5170 }
5171
5172 ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
5173                      const char *isysroot, bool DisableValidation,
5174                      bool DisableStatCache)
5175   : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5176     SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5177     Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
5178     Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation),
5179     DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5180     NumSLocEntriesRead(0), TotalNumSLocEntries(0), NextSLocOffset(0),
5181     NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5182     TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5183     NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5184     NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5185     NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5186     NumCurrentElementsDeserializing(0)
5187 {
5188   RelocatablePCH = false;
5189 }
5190
5191 ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
5192                      Diagnostic &Diags, const char *isysroot,
5193                      bool DisableValidation, bool DisableStatCache)
5194   : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
5195     Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0),
5196     isysroot(isysroot), DisableValidation(DisableValidation),
5197     DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5198     NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5199     NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0),
5200     NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0),
5201     NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
5202     TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5203     TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
5204     TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) {
5205   RelocatablePCH = false;
5206 }
5207
5208 ASTReader::~ASTReader() {
5209   for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5210     delete Chain[e - i - 1];
5211   // Delete all visible decl lookup tables
5212   for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5213                                        E = DeclContextOffsets.end();
5214        I != E; ++I) {
5215     for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5216          J != F; ++J) {
5217       if (J->NameLookupTableData)
5218         delete static_cast<ASTDeclContextNameLookupTable*>(
5219             J->NameLookupTableData);
5220     }
5221   }
5222   for (DeclContextVisibleUpdatesPending::iterator
5223            I = PendingVisibleUpdates.begin(),
5224            E = PendingVisibleUpdates.end();
5225        I != E; ++I) {
5226     for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5227                                              F = I->second.end();
5228          J != F; ++J)
5229       delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5230   }
5231 }
5232
5233 ASTReader::PerFileData::PerFileData(ASTFileType Ty)
5234   : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0),
5235     SLocFileOffsets(0), LocalSLocSize(0),
5236     LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0),
5237     IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
5238     MacroDefinitionOffsets(0),
5239     LocalNumHeaderFileInfos(0), HeaderFileInfoTableData(0),
5240     HeaderFileInfoTable(0),
5241     LocalNumSelectors(0), SelectorOffsets(0),
5242     SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5243     DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5244     LocalNumTypes(0), TypeOffsets(0), StatCache(0),
5245     NumPreallocatedPreprocessingEntities(0), NextInSource(0)
5246 {}
5247
5248 ASTReader::PerFileData::~PerFileData() {
5249   delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5250   delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5251   delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5252 }