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