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