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