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