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