ASTReader.cpp revision ad762fcdc16b9e4705b12b09d92b8c026212b906 
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  if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
2680    Context->AutoDeductTy = GetType(AutoDeduct);
2681  if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
2682    Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
2683
2684  ReadPragmaDiagnosticMappings(Context->getDiagnostics());
2685
2686  // If there were any CUDA special declarations, deserialize them.
2687  if (!CUDASpecialDeclRefs.empty()) {
2688    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2689    Context->setcudaConfigureCallDecl(
2690                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2691  }
2692}
2693
2694/// \brief Retrieve the name of the original source file name
2695/// directly from the AST file, without actually loading the AST
2696/// file.
2697std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2698                                             FileManager &FileMgr,
2699                                             Diagnostic &Diags) {
2700  // Open the AST file.
2701  std::string ErrStr;
2702  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
2703  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2704  if (!Buffer) {
2705    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2706    return std::string();
2707  }
2708
2709  // Initialize the stream
2710  llvm::BitstreamReader StreamFile;
2711  llvm::BitstreamCursor Stream;
2712  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
2713                  (const unsigned char *)Buffer->getBufferEnd());
2714  Stream.init(StreamFile);
2715
2716  // Sniff for the signature.
2717  if (Stream.Read(8) != 'C' ||
2718      Stream.Read(8) != 'P' ||
2719      Stream.Read(8) != 'C' ||
2720      Stream.Read(8) != 'H') {
2721    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
2722    return std::string();
2723  }
2724
2725  RecordData Record;
2726  while (!Stream.AtEndOfStream()) {
2727    unsigned Code = Stream.ReadCode();
2728
2729    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2730      unsigned BlockID = Stream.ReadSubBlockID();
2731
2732      // We only know the AST subblock ID.
2733      switch (BlockID) {
2734      case AST_BLOCK_ID:
2735        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2736          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2737          return std::string();
2738        }
2739        break;
2740
2741      default:
2742        if (Stream.SkipBlock()) {
2743          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2744          return std::string();
2745        }
2746        break;
2747      }
2748      continue;
2749    }
2750
2751    if (Code == llvm::bitc::END_BLOCK) {
2752      if (Stream.ReadBlockEnd()) {
2753        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
2754        return std::string();
2755      }
2756      continue;
2757    }
2758
2759    if (Code == llvm::bitc::DEFINE_ABBREV) {
2760      Stream.ReadAbbrevRecord();
2761      continue;
2762    }
2763
2764    Record.clear();
2765    const char *BlobStart = 0;
2766    unsigned BlobLen = 0;
2767    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
2768          == ORIGINAL_FILE_NAME)
2769      return std::string(BlobStart, BlobLen);
2770  }
2771
2772  return std::string();
2773}
2774
2775/// \brief Parse the record that corresponds to a LangOptions data
2776/// structure.
2777///
2778/// This routine parses the language options from the AST file and then gives
2779/// them to the AST listener if one is set.
2780///
2781/// \returns true if the listener deems the file unacceptable, false otherwise.
2782bool ASTReader::ParseLanguageOptions(
2783                             const llvm::SmallVectorImpl<uint64_t> &Record) {
2784  if (Listener) {
2785    LangOptions LangOpts;
2786
2787  #define PARSE_LANGOPT(Option)                  \
2788      LangOpts.Option = Record[Idx];             \
2789      ++Idx
2790
2791    unsigned Idx = 0;
2792    PARSE_LANGOPT(Trigraphs);
2793    PARSE_LANGOPT(BCPLComment);
2794    PARSE_LANGOPT(DollarIdents);
2795    PARSE_LANGOPT(AsmPreprocessor);
2796    PARSE_LANGOPT(GNUMode);
2797    PARSE_LANGOPT(GNUKeywords);
2798    PARSE_LANGOPT(ImplicitInt);
2799    PARSE_LANGOPT(Digraphs);
2800    PARSE_LANGOPT(HexFloats);
2801    PARSE_LANGOPT(C99);
2802    PARSE_LANGOPT(Microsoft);
2803    PARSE_LANGOPT(CPlusPlus);
2804    PARSE_LANGOPT(CPlusPlus0x);
2805    PARSE_LANGOPT(CXXOperatorNames);
2806    PARSE_LANGOPT(ObjC1);
2807    PARSE_LANGOPT(ObjC2);
2808    PARSE_LANGOPT(ObjCNonFragileABI);
2809    PARSE_LANGOPT(ObjCNonFragileABI2);
2810    PARSE_LANGOPT(AppleKext);
2811    PARSE_LANGOPT(ObjCDefaultSynthProperties);
2812    PARSE_LANGOPT(NoConstantCFStrings);
2813    PARSE_LANGOPT(PascalStrings);
2814    PARSE_LANGOPT(WritableStrings);
2815    PARSE_LANGOPT(LaxVectorConversions);
2816    PARSE_LANGOPT(AltiVec);
2817    PARSE_LANGOPT(Exceptions);
2818    PARSE_LANGOPT(ObjCExceptions);
2819    PARSE_LANGOPT(CXXExceptions);
2820    PARSE_LANGOPT(SjLjExceptions);
2821    PARSE_LANGOPT(MSBitfields);
2822    PARSE_LANGOPT(NeXTRuntime);
2823    PARSE_LANGOPT(Freestanding);
2824    PARSE_LANGOPT(NoBuiltin);
2825    PARSE_LANGOPT(ThreadsafeStatics);
2826    PARSE_LANGOPT(POSIXThreads);
2827    PARSE_LANGOPT(Blocks);
2828    PARSE_LANGOPT(EmitAllDecls);
2829    PARSE_LANGOPT(MathErrno);
2830    LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
2831                                       Record[Idx++]);
2832    PARSE_LANGOPT(HeinousExtensions);
2833    PARSE_LANGOPT(Optimize);
2834    PARSE_LANGOPT(OptimizeSize);
2835    PARSE_LANGOPT(Static);
2836    PARSE_LANGOPT(PICLevel);
2837    PARSE_LANGOPT(GNUInline);
2838    PARSE_LANGOPT(NoInline);
2839    PARSE_LANGOPT(AccessControl);
2840    PARSE_LANGOPT(CharIsSigned);
2841    PARSE_LANGOPT(ShortWChar);
2842    PARSE_LANGOPT(ShortEnums);
2843    LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
2844    LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
2845    LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
2846                                   Record[Idx++]);
2847    PARSE_LANGOPT(InstantiationDepth);
2848    PARSE_LANGOPT(OpenCL);
2849    PARSE_LANGOPT(CUDA);
2850    PARSE_LANGOPT(CatchUndefined);
2851    PARSE_LANGOPT(DefaultFPContract);
2852    PARSE_LANGOPT(ElideConstructors);
2853    PARSE_LANGOPT(SpellChecking);
2854    PARSE_LANGOPT(MRTD);
2855  #undef PARSE_LANGOPT
2856
2857    return Listener->ReadLanguageOptions(LangOpts);
2858  }
2859
2860  return false;
2861}
2862
2863void ASTReader::ReadPreprocessedEntities() {
2864  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2865    PerFileData &F = *Chain[I];
2866    if (!F.PreprocessorDetailCursor.getBitStreamReader())
2867      continue;
2868
2869    SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
2870    F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
2871    while (LoadPreprocessedEntity(F)) { }
2872  }
2873}
2874
2875PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
2876  PerFileData *F = 0;
2877  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2878    if (Offset < Chain[I]->SizeInBits) {
2879      F = Chain[I];
2880      break;
2881    }
2882
2883    Offset -= Chain[I]->SizeInBits;
2884  }
2885
2886  if (!F) {
2887    Error("Malformed preprocessed entity offset");
2888    return 0;
2889  }
2890
2891  // Keep track of where we are in the stream, then jump back there
2892  // after reading this entity.
2893  SavedStreamPosition SavedPosition(F->PreprocessorDetailCursor);
2894  F->PreprocessorDetailCursor.JumpToBit(Offset);
2895  return LoadPreprocessedEntity(*F);
2896}
2897
2898HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
2899  HeaderFileInfoTrait Trait(FE->getName());
2900  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2901    PerFileData &F = *Chain[I];
2902    HeaderFileInfoLookupTable *Table
2903      = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
2904    if (!Table)
2905      continue;
2906
2907    // Look in the on-disk hash table for an entry for this file name.
2908    HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
2909                                                          &Trait);
2910    if (Pos == Table->end())
2911      continue;
2912
2913    HeaderFileInfo HFI = *Pos;
2914    if (Listener)
2915      Listener->ReadHeaderFileInfo(HFI, FE->getUID());
2916
2917    return HFI;
2918  }
2919
2920  return HeaderFileInfo();
2921}
2922
2923void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
2924  unsigned Idx = 0;
2925  while (Idx < PragmaDiagMappings.size()) {
2926    SourceLocation
2927      Loc = SourceLocation::getFromRawEncoding(PragmaDiagMappings[Idx++]);
2928    while (1) {
2929      assert(Idx < PragmaDiagMappings.size() &&
2930             "Invalid data, didn't find '-1' marking end of diag/map pairs");
2931      if (Idx >= PragmaDiagMappings.size())
2932        break; // Something is messed up but at least avoid infinite loop in
2933               // release build.
2934      unsigned DiagID = PragmaDiagMappings[Idx++];
2935      if (DiagID == (unsigned)-1)
2936        break; // no more diag/map pairs for this location.
2937      diag::Mapping Map = (diag::Mapping)PragmaDiagMappings[Idx++];
2938      Diag.setDiagnosticMapping(DiagID, Map, Loc);
2939    }
2940  }
2941}
2942
2943/// \brief Get the correct cursor and offset for loading a type.
2944ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
2945  PerFileData *F = 0;
2946  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
2947    F = Chain[N - I - 1];
2948    if (Index < F->LocalNumTypes)
2949      break;
2950    Index -= F->LocalNumTypes;
2951  }
2952  assert(F && F->LocalNumTypes > Index && "Broken chain");
2953  return RecordLocation(F, F->TypeOffsets[Index]);
2954}
2955
2956/// \brief Read and return the type with the given index..
2957///
2958/// The index is the type ID, shifted and minus the number of predefs. This
2959/// routine actually reads the record corresponding to the type at the given
2960/// location. It is a helper routine for GetType, which deals with reading type
2961/// IDs.
2962QualType ASTReader::ReadTypeRecord(unsigned Index) {
2963  RecordLocation Loc = TypeCursorForIndex(Index);
2964  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
2965
2966  // Keep track of where we are in the stream, then jump back there
2967  // after reading this type.
2968  SavedStreamPosition SavedPosition(DeclsCursor);
2969
2970  ReadingKindTracker ReadingKind(Read_Type, *this);
2971
2972  // Note that we are loading a type record.
2973  Deserializing AType(this);
2974
2975  DeclsCursor.JumpToBit(Loc.Offset);
2976  RecordData Record;
2977  unsigned Code = DeclsCursor.ReadCode();
2978  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
2979  case TYPE_EXT_QUAL: {
2980    if (Record.size() != 2) {
2981      Error("Incorrect encoding of extended qualifier type");
2982      return QualType();
2983    }
2984    QualType Base = GetType(Record[0]);
2985    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[1]);
2986    return Context->getQualifiedType(Base, Quals);
2987  }
2988
2989  case TYPE_COMPLEX: {
2990    if (Record.size() != 1) {
2991      Error("Incorrect encoding of complex type");
2992      return QualType();
2993    }
2994    QualType ElemType = GetType(Record[0]);
2995    return Context->getComplexType(ElemType);
2996  }
2997
2998  case TYPE_POINTER: {
2999    if (Record.size() != 1) {
3000      Error("Incorrect encoding of pointer type");
3001      return QualType();
3002    }
3003    QualType PointeeType = GetType(Record[0]);
3004    return Context->getPointerType(PointeeType);
3005  }
3006
3007  case TYPE_BLOCK_POINTER: {
3008    if (Record.size() != 1) {
3009      Error("Incorrect encoding of block pointer type");
3010      return QualType();
3011    }
3012    QualType PointeeType = GetType(Record[0]);
3013    return Context->getBlockPointerType(PointeeType);
3014  }
3015
3016  case TYPE_LVALUE_REFERENCE: {
3017    if (Record.size() != 2) {
3018      Error("Incorrect encoding of lvalue reference type");
3019      return QualType();
3020    }
3021    QualType PointeeType = GetType(Record[0]);
3022    return Context->getLValueReferenceType(PointeeType, Record[1]);
3023  }
3024
3025  case TYPE_RVALUE_REFERENCE: {
3026    if (Record.size() != 1) {
3027      Error("Incorrect encoding of rvalue reference type");
3028      return QualType();
3029    }
3030    QualType PointeeType = GetType(Record[0]);
3031    return Context->getRValueReferenceType(PointeeType);
3032  }
3033
3034  case TYPE_MEMBER_POINTER: {
3035    if (Record.size() != 2) {
3036      Error("Incorrect encoding of member pointer type");
3037      return QualType();
3038    }
3039    QualType PointeeType = GetType(Record[0]);
3040    QualType ClassType = GetType(Record[1]);
3041    if (PointeeType.isNull() || ClassType.isNull())
3042      return QualType();
3043
3044    return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3045  }
3046
3047  case TYPE_CONSTANT_ARRAY: {
3048    QualType ElementType = GetType(Record[0]);
3049    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3050    unsigned IndexTypeQuals = Record[2];
3051    unsigned Idx = 3;
3052    llvm::APInt Size = ReadAPInt(Record, Idx);
3053    return Context->getConstantArrayType(ElementType, Size,
3054                                         ASM, IndexTypeQuals);
3055  }
3056
3057  case TYPE_INCOMPLETE_ARRAY: {
3058    QualType ElementType = GetType(Record[0]);
3059    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3060    unsigned IndexTypeQuals = Record[2];
3061    return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3062  }
3063
3064  case TYPE_VARIABLE_ARRAY: {
3065    QualType ElementType = GetType(Record[0]);
3066    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3067    unsigned IndexTypeQuals = Record[2];
3068    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3069    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3070    return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3071                                         ASM, IndexTypeQuals,
3072                                         SourceRange(LBLoc, RBLoc));
3073  }
3074
3075  case TYPE_VECTOR: {
3076    if (Record.size() != 3) {
3077      Error("incorrect encoding of vector type in AST file");
3078      return QualType();
3079    }
3080
3081    QualType ElementType = GetType(Record[0]);
3082    unsigned NumElements = Record[1];
3083    unsigned VecKind = Record[2];
3084    return Context->getVectorType(ElementType, NumElements,
3085                                  (VectorType::VectorKind)VecKind);
3086  }
3087
3088  case TYPE_EXT_VECTOR: {
3089    if (Record.size() != 3) {
3090      Error("incorrect encoding of extended vector type in AST file");
3091      return QualType();
3092    }
3093
3094    QualType ElementType = GetType(Record[0]);
3095    unsigned NumElements = Record[1];
3096    return Context->getExtVectorType(ElementType, NumElements);
3097  }
3098
3099  case TYPE_FUNCTION_NO_PROTO: {
3100    if (Record.size() != 5) {
3101      Error("incorrect encoding of no-proto function type");
3102      return QualType();
3103    }
3104    QualType ResultType = GetType(Record[0]);
3105    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], (CallingConv)Record[4]);
3106    return Context->getFunctionNoProtoType(ResultType, Info);
3107  }
3108
3109  case TYPE_FUNCTION_PROTO: {
3110    QualType ResultType = GetType(Record[0]);
3111
3112    FunctionProtoType::ExtProtoInfo EPI;
3113    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3114                                        /*hasregparm*/ Record[2],
3115                                        /*regparm*/ Record[3],
3116                                        static_cast<CallingConv>(Record[4]));
3117
3118    unsigned Idx = 5;
3119    unsigned NumParams = Record[Idx++];
3120    llvm::SmallVector<QualType, 16> ParamTypes;
3121    for (unsigned I = 0; I != NumParams; ++I)
3122      ParamTypes.push_back(GetType(Record[Idx++]));
3123
3124    EPI.Variadic = Record[Idx++];
3125    EPI.TypeQuals = Record[Idx++];
3126    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3127    ExceptionSpecificationType EST =
3128        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3129    EPI.ExceptionSpecType = EST;
3130    if (EST == EST_Dynamic) {
3131      EPI.NumExceptions = Record[Idx++];
3132      llvm::SmallVector<QualType, 2> Exceptions;
3133      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3134        Exceptions.push_back(GetType(Record[Idx++]));
3135      EPI.Exceptions = Exceptions.data();
3136    } else if (EST == EST_ComputedNoexcept) {
3137      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3138    }
3139    return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3140                                    EPI);
3141  }
3142
3143  case TYPE_UNRESOLVED_USING:
3144    return Context->getTypeDeclType(
3145             cast<UnresolvedUsingTypenameDecl>(GetDecl(Record[0])));
3146
3147  case TYPE_TYPEDEF: {
3148    if (Record.size() != 2) {
3149      Error("incorrect encoding of typedef type");
3150      return QualType();
3151    }
3152    TypedefDecl *Decl = cast<TypedefDecl>(GetDecl(Record[0]));
3153    QualType Canonical = GetType(Record[1]);
3154    if (!Canonical.isNull())
3155      Canonical = Context->getCanonicalType(Canonical);
3156    return Context->getTypedefType(Decl, Canonical);
3157  }
3158
3159  case TYPE_TYPEOF_EXPR:
3160    return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3161
3162  case TYPE_TYPEOF: {
3163    if (Record.size() != 1) {
3164      Error("incorrect encoding of typeof(type) in AST file");
3165      return QualType();
3166    }
3167    QualType UnderlyingType = GetType(Record[0]);
3168    return Context->getTypeOfType(UnderlyingType);
3169  }
3170
3171  case TYPE_DECLTYPE:
3172    return Context->getDecltypeType(ReadExpr(*Loc.F));
3173
3174  case TYPE_AUTO:
3175    return Context->getAutoType(GetType(Record[0]));
3176
3177  case TYPE_RECORD: {
3178    if (Record.size() != 2) {
3179      Error("incorrect encoding of record type");
3180      return QualType();
3181    }
3182    bool IsDependent = Record[0];
3183    QualType T = Context->getRecordType(cast<RecordDecl>(GetDecl(Record[1])));
3184    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3185    return T;
3186  }
3187
3188  case TYPE_ENUM: {
3189    if (Record.size() != 2) {
3190      Error("incorrect encoding of enum type");
3191      return QualType();
3192    }
3193    bool IsDependent = Record[0];
3194    QualType T = Context->getEnumType(cast<EnumDecl>(GetDecl(Record[1])));
3195    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3196    return T;
3197  }
3198
3199  case TYPE_ATTRIBUTED: {
3200    if (Record.size() != 3) {
3201      Error("incorrect encoding of attributed type");
3202      return QualType();
3203    }
3204    QualType modifiedType = GetType(Record[0]);
3205    QualType equivalentType = GetType(Record[1]);
3206    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3207    return Context->getAttributedType(kind, modifiedType, equivalentType);
3208  }
3209
3210  case TYPE_PAREN: {
3211    if (Record.size() != 1) {
3212      Error("incorrect encoding of paren type");
3213      return QualType();
3214    }
3215    QualType InnerType = GetType(Record[0]);
3216    return Context->getParenType(InnerType);
3217  }
3218
3219  case TYPE_PACK_EXPANSION: {
3220    if (Record.size() != 2) {
3221      Error("incorrect encoding of pack expansion type");
3222      return QualType();
3223    }
3224    QualType Pattern = GetType(Record[0]);
3225    if (Pattern.isNull())
3226      return QualType();
3227    llvm::Optional<unsigned> NumExpansions;
3228    if (Record[1])
3229      NumExpansions = Record[1] - 1;
3230    return Context->getPackExpansionType(Pattern, NumExpansions);
3231  }
3232
3233  case TYPE_ELABORATED: {
3234    unsigned Idx = 0;
3235    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3236    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3237    QualType NamedType = GetType(Record[Idx++]);
3238    return Context->getElaboratedType(Keyword, NNS, NamedType);
3239  }
3240
3241  case TYPE_OBJC_INTERFACE: {
3242    unsigned Idx = 0;
3243    ObjCInterfaceDecl *ItfD = cast<ObjCInterfaceDecl>(GetDecl(Record[Idx++]));
3244    return Context->getObjCInterfaceType(ItfD);
3245  }
3246
3247  case TYPE_OBJC_OBJECT: {
3248    unsigned Idx = 0;
3249    QualType Base = GetType(Record[Idx++]);
3250    unsigned NumProtos = Record[Idx++];
3251    llvm::SmallVector<ObjCProtocolDecl*, 4> Protos;
3252    for (unsigned I = 0; I != NumProtos; ++I)
3253      Protos.push_back(cast<ObjCProtocolDecl>(GetDecl(Record[Idx++])));
3254    return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3255  }
3256
3257  case TYPE_OBJC_OBJECT_POINTER: {
3258    unsigned Idx = 0;
3259    QualType Pointee = GetType(Record[Idx++]);
3260    return Context->getObjCObjectPointerType(Pointee);
3261  }
3262
3263  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3264    unsigned Idx = 0;
3265    QualType Parm = GetType(Record[Idx++]);
3266    QualType Replacement = GetType(Record[Idx++]);
3267    return
3268      Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3269                                            Replacement);
3270  }
3271
3272  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3273    unsigned Idx = 0;
3274    QualType Parm = GetType(Record[Idx++]);
3275    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3276    return Context->getSubstTemplateTypeParmPackType(
3277                                               cast<TemplateTypeParmType>(Parm),
3278                                                     ArgPack);
3279  }
3280
3281  case TYPE_INJECTED_CLASS_NAME: {
3282    CXXRecordDecl *D = cast<CXXRecordDecl>(GetDecl(Record[0]));
3283    QualType TST = GetType(Record[1]); // probably derivable
3284    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3285    // for AST reading, too much interdependencies.
3286    return
3287      QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3288  }
3289
3290  case TYPE_TEMPLATE_TYPE_PARM: {
3291    unsigned Idx = 0;
3292    unsigned Depth = Record[Idx++];
3293    unsigned Index = Record[Idx++];
3294    bool Pack = Record[Idx++];
3295    IdentifierInfo *Name = GetIdentifierInfo(Record, Idx);
3296    return Context->getTemplateTypeParmType(Depth, Index, Pack, Name);
3297  }
3298
3299  case TYPE_DEPENDENT_NAME: {
3300    unsigned Idx = 0;
3301    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3302    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3303    const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3304    QualType Canon = GetType(Record[Idx++]);
3305    if (!Canon.isNull())
3306      Canon = Context->getCanonicalType(Canon);
3307    return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3308  }
3309
3310  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3311    unsigned Idx = 0;
3312    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3313    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
3314    const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3315    unsigned NumArgs = Record[Idx++];
3316    llvm::SmallVector<TemplateArgument, 8> Args;
3317    Args.reserve(NumArgs);
3318    while (NumArgs--)
3319      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3320    return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3321                                                      Args.size(), Args.data());
3322  }
3323
3324  case TYPE_DEPENDENT_SIZED_ARRAY: {
3325    unsigned Idx = 0;
3326
3327    // ArrayType
3328    QualType ElementType = GetType(Record[Idx++]);
3329    ArrayType::ArraySizeModifier ASM
3330      = (ArrayType::ArraySizeModifier)Record[Idx++];
3331    unsigned IndexTypeQuals = Record[Idx++];
3332
3333    // DependentSizedArrayType
3334    Expr *NumElts = ReadExpr(*Loc.F);
3335    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3336
3337    return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3338                                               IndexTypeQuals, Brackets);
3339  }
3340
3341  case TYPE_TEMPLATE_SPECIALIZATION: {
3342    unsigned Idx = 0;
3343    bool IsDependent = Record[Idx++];
3344    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3345    llvm::SmallVector<TemplateArgument, 8> Args;
3346    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3347    QualType Canon = GetType(Record[Idx++]);
3348    QualType T;
3349    if (Canon.isNull())
3350      T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3351                                                          Args.size());
3352    else
3353      T = Context->getTemplateSpecializationType(Name, Args.data(),
3354                                                 Args.size(), Canon);
3355    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3356    return T;
3357  }
3358  }
3359  // Suppress a GCC warning
3360  return QualType();
3361}
3362
3363class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3364  ASTReader &Reader;
3365  ASTReader::PerFileData &F;
3366  llvm::BitstreamCursor &DeclsCursor;
3367  const ASTReader::RecordData &Record;
3368  unsigned &Idx;
3369
3370  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3371                                    unsigned &I) {
3372    return Reader.ReadSourceLocation(F, R, I);
3373  }
3374
3375public:
3376  TypeLocReader(ASTReader &Reader, ASTReader::PerFileData &F,
3377                const ASTReader::RecordData &Record, unsigned &Idx)
3378    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3379  { }
3380
3381  // We want compile-time assurance that we've enumerated all of
3382  // these, so unfortunately we have to declare them first, then
3383  // define them out-of-line.
3384#define ABSTRACT_TYPELOC(CLASS, PARENT)
3385#define TYPELOC(CLASS, PARENT) \
3386  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3387#include "clang/AST/TypeLocNodes.def"
3388
3389  void VisitFunctionTypeLoc(FunctionTypeLoc);
3390  void VisitArrayTypeLoc(ArrayTypeLoc);
3391};
3392
3393void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3394  // nothing to do
3395}
3396void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3397  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3398  if (TL.needsExtraLocalData()) {
3399    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3400    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3401    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3402    TL.setModeAttr(Record[Idx++]);
3403  }
3404}
3405void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3406  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3407}
3408void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3409  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3410}
3411void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3412  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3413}
3414void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3415  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3416}
3417void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3418  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3419}
3420void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3421  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3422  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3423}
3424void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3425  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3426  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3427  if (Record[Idx++])
3428    TL.setSizeExpr(Reader.ReadExpr(F));
3429  else
3430    TL.setSizeExpr(0);
3431}
3432void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3433  VisitArrayTypeLoc(TL);
3434}
3435void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3436  VisitArrayTypeLoc(TL);
3437}
3438void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3439  VisitArrayTypeLoc(TL);
3440}
3441void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3442                                            DependentSizedArrayTypeLoc TL) {
3443  VisitArrayTypeLoc(TL);
3444}
3445void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3446                                        DependentSizedExtVectorTypeLoc TL) {
3447  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3448}
3449void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3450  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3451}
3452void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3453  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3454}
3455void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3456  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3457  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3458  TL.setTrailingReturn(Record[Idx++]);
3459  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3460    TL.setArg(i, cast_or_null<ParmVarDecl>(Reader.GetDecl(Record[Idx++])));
3461  }
3462}
3463void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3464  VisitFunctionTypeLoc(TL);
3465}
3466void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3467  VisitFunctionTypeLoc(TL);
3468}
3469void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3470  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3471}
3472void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3473  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3474}
3475void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3476  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3477  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3478  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3479}
3480void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3481  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3482  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3483  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3484  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3485}
3486void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3487  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3488}
3489void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3490  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3491}
3492void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3493  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3494}
3495void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3496  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3497}
3498void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3499  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3500  if (TL.hasAttrOperand()) {
3501    SourceRange range;
3502    range.setBegin(ReadSourceLocation(Record, Idx));
3503    range.setEnd(ReadSourceLocation(Record, Idx));
3504    TL.setAttrOperandParensRange(range);
3505  }
3506  if (TL.hasAttrExprOperand()) {
3507    if (Record[Idx++])
3508      TL.setAttrExprOperand(Reader.ReadExpr(F));
3509    else
3510      TL.setAttrExprOperand(0);
3511  } else if (TL.hasAttrEnumOperand())
3512    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3513}
3514void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3515  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3516}
3517void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3518                                            SubstTemplateTypeParmTypeLoc TL) {
3519  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3520}
3521void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3522                                          SubstTemplateTypeParmPackTypeLoc TL) {
3523  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3524}
3525void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3526                                           TemplateSpecializationTypeLoc TL) {
3527  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3528  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3529  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3530  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3531    TL.setArgLocInfo(i,
3532        Reader.GetTemplateArgumentLocInfo(F,
3533                                          TL.getTypePtr()->getArg(i).getKind(),
3534                                          Record, Idx));
3535}
3536void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3537  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3538  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3539}
3540void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3541  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3542  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3543}
3544void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3545  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3546}
3547void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3548  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3549  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3550  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3551}
3552void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3553       DependentTemplateSpecializationTypeLoc TL) {
3554  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3555  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3556  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3557  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3558  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3559  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3560    TL.setArgLocInfo(I,
3561        Reader.GetTemplateArgumentLocInfo(F,
3562                                          TL.getTypePtr()->getArg(I).getKind(),
3563                                          Record, Idx));
3564}
3565void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3566  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3567}
3568void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3569  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3570}
3571void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3572  TL.setHasBaseTypeAsWritten(Record[Idx++]);
3573  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3574  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3575  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3576    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3577}
3578void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3579  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3580}
3581
3582TypeSourceInfo *ASTReader::GetTypeSourceInfo(PerFileData &F,
3583                                             const RecordData &Record,
3584                                             unsigned &Idx) {
3585  QualType InfoTy = GetType(Record[Idx++]);
3586  if (InfoTy.isNull())
3587    return 0;
3588
3589  TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
3590  TypeLocReader TLR(*this, F, Record, Idx);
3591  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
3592    TLR.Visit(TL);
3593  return TInfo;
3594}
3595
3596QualType ASTReader::GetType(TypeID ID) {
3597  unsigned FastQuals = ID & Qualifiers::FastMask;
3598  unsigned Index = ID >> Qualifiers::FastWidth;
3599
3600  if (Index < NUM_PREDEF_TYPE_IDS) {
3601    QualType T;
3602    switch ((PredefinedTypeIDs)Index) {
3603    case PREDEF_TYPE_NULL_ID: return QualType();
3604    case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3605    case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
3606
3607    case PREDEF_TYPE_CHAR_U_ID:
3608    case PREDEF_TYPE_CHAR_S_ID:
3609      // FIXME: Check that the signedness of CharTy is correct!
3610      T = Context->CharTy;
3611      break;
3612
3613    case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
3614    case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
3615    case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
3616    case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
3617    case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
3618    case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
3619    case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
3620    case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
3621    case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
3622    case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
3623    case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
3624    case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
3625    case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
3626    case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
3627    case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
3628    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
3629    case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
3630    case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
3631    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
3632    case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
3633    case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
3634    case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
3635    case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
3636    case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
3637    case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
3638    }
3639
3640    assert(!T.isNull() && "Unknown predefined type");
3641    return T.withFastQualifiers(FastQuals);
3642  }
3643
3644  Index -= NUM_PREDEF_TYPE_IDS;
3645  assert(Index < TypesLoaded.size() && "Type index out-of-range");
3646  if (TypesLoaded[Index].isNull()) {
3647    TypesLoaded[Index] = ReadTypeRecord(Index);
3648    if (TypesLoaded[Index].isNull())
3649      return QualType();
3650
3651    TypesLoaded[Index]->setFromAST();
3652    TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID);
3653    if (DeserializationListener)
3654      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
3655                                        TypesLoaded[Index]);
3656  }
3657
3658  return TypesLoaded[Index].withFastQualifiers(FastQuals);
3659}
3660
3661TypeID ASTReader::GetTypeID(QualType T) const {
3662  return MakeTypeID(T,
3663              std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
3664}
3665
3666TypeIdx ASTReader::GetTypeIdx(QualType T) const {
3667  if (T.isNull())
3668    return TypeIdx();
3669  assert(!T.getLocalFastQualifiers());
3670
3671  TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3672  // GetTypeIdx is mostly used for computing the hash of DeclarationNames and
3673  // comparing keys of ASTDeclContextNameLookupTable.
3674  // If the type didn't come from the AST file use a specially marked index
3675  // so that any hash/key comparison fail since no such index is stored
3676  // in a AST file.
3677  if (I == TypeIdxs.end())
3678    return TypeIdx(-1);
3679  return I->second;
3680}
3681
3682unsigned ASTReader::getTotalNumCXXBaseSpecifiers() const {
3683  unsigned Result = 0;
3684  for (unsigned I = 0, N = Chain.size(); I != N; ++I)
3685    Result += Chain[I]->LocalNumCXXBaseSpecifiers;
3686
3687  return Result;
3688}
3689
3690TemplateArgumentLocInfo
3691ASTReader::GetTemplateArgumentLocInfo(PerFileData &F,
3692                                      TemplateArgument::ArgKind Kind,
3693                                      const RecordData &Record,
3694                                      unsigned &Index) {
3695  switch (Kind) {
3696  case TemplateArgument::Expression:
3697    return ReadExpr(F);
3698  case TemplateArgument::Type:
3699    return GetTypeSourceInfo(F, Record, Index);
3700  case TemplateArgument::Template: {
3701    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3702                                                                     Index);
3703    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3704    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3705                                   SourceLocation());
3706  }
3707  case TemplateArgument::TemplateExpansion: {
3708    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3709                                                                     Index);
3710    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3711    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
3712    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3713                                   EllipsisLoc);
3714  }
3715  case TemplateArgument::Null:
3716  case TemplateArgument::Integral:
3717  case TemplateArgument::Declaration:
3718  case TemplateArgument::Pack:
3719    return TemplateArgumentLocInfo();
3720  }
3721  llvm_unreachable("unexpected template argument loc");
3722  return TemplateArgumentLocInfo();
3723}
3724
3725TemplateArgumentLoc
3726ASTReader::ReadTemplateArgumentLoc(PerFileData &F,
3727                                   const RecordData &Record, unsigned &Index) {
3728  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
3729
3730  if (Arg.getKind() == TemplateArgument::Expression) {
3731    if (Record[Index++]) // bool InfoHasSameExpr.
3732      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
3733  }
3734  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
3735                                                             Record, Index));
3736}
3737
3738Decl *ASTReader::GetExternalDecl(uint32_t ID) {
3739  return GetDecl(ID);
3740}
3741
3742uint64_t
3743ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
3744  if (ID == 0)
3745    return 0;
3746
3747  --ID;
3748  uint64_t Offset = 0;
3749  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3750    PerFileData &F = *Chain[N - I - 1];
3751
3752    if (ID < F.LocalNumCXXBaseSpecifiers)
3753      return Offset + F.CXXBaseSpecifiersOffsets[ID];
3754
3755    ID -= F.LocalNumCXXBaseSpecifiers;
3756    Offset += F.SizeInBits;
3757  }
3758
3759  assert(false && "CXXBaseSpecifiers not found");
3760  return 0;
3761}
3762
3763CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
3764  // Figure out which AST file contains this offset.
3765  PerFileData *F = 0;
3766  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3767    if (Offset < Chain[N - I - 1]->SizeInBits) {
3768      F = Chain[N - I - 1];
3769      break;
3770    }
3771
3772    Offset -= Chain[N - I - 1]->SizeInBits;
3773  }
3774
3775  if (!F) {
3776    Error("Malformed AST file: C++ base specifiers at impossible offset");
3777    return 0;
3778  }
3779
3780  llvm::BitstreamCursor &Cursor = F->DeclsCursor;
3781  SavedStreamPosition SavedPosition(Cursor);
3782  Cursor.JumpToBit(Offset);
3783  ReadingKindTracker ReadingKind(Read_Decl, *this);
3784  RecordData Record;
3785  unsigned Code = Cursor.ReadCode();
3786  unsigned RecCode = Cursor.ReadRecord(Code, Record);
3787  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
3788    Error("Malformed AST file: missing C++ base specifiers");
3789    return 0;
3790  }
3791
3792  unsigned Idx = 0;
3793  unsigned NumBases = Record[Idx++];
3794  void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
3795  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
3796  for (unsigned I = 0; I != NumBases; ++I)
3797    Bases[I] = ReadCXXBaseSpecifier(*F, Record, Idx);
3798  return Bases;
3799}
3800
3801TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
3802  if (!DeclsLoaded[0]) {
3803    ReadDeclRecord(0, 1);
3804    if (DeserializationListener)
3805      DeserializationListener->DeclRead(1, DeclsLoaded[0]);
3806  }
3807
3808  return cast<TranslationUnitDecl>(DeclsLoaded[0]);
3809}
3810
3811Decl *ASTReader::GetDecl(DeclID ID) {
3812  if (ID == 0)
3813    return 0;
3814
3815  if (ID > DeclsLoaded.size()) {
3816    Error("declaration ID out-of-range for AST file");
3817    return 0;
3818  }
3819
3820  unsigned Index = ID - 1;
3821  if (!DeclsLoaded[Index]) {
3822    ReadDeclRecord(Index, ID);
3823    if (DeserializationListener)
3824      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
3825  }
3826
3827  return DeclsLoaded[Index];
3828}
3829
3830/// \brief Resolve the offset of a statement into a statement.
3831///
3832/// This operation will read a new statement from the external
3833/// source each time it is called, and is meant to be used via a
3834/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
3835Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
3836  // Switch case IDs are per Decl.
3837  ClearSwitchCaseIDs();
3838
3839  // Offset here is a global offset across the entire chain.
3840  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
3841    PerFileData &F = *Chain[N - I - 1];
3842    if (Offset < F.SizeInBits) {
3843      // Since we know that this statement is part of a decl, make sure to use
3844      // the decl cursor to read it.
3845      F.DeclsCursor.JumpToBit(Offset);
3846      return ReadStmtFromStream(F);
3847    }
3848    Offset -= F.SizeInBits;
3849  }
3850  llvm_unreachable("Broken chain");
3851}
3852
3853bool ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
3854                                         bool (*isKindWeWant)(Decl::Kind),
3855                                         llvm::SmallVectorImpl<Decl*> &Decls) {
3856  assert(DC->hasExternalLexicalStorage() &&
3857         "DeclContext has no lexical decls in storage");
3858
3859  // There might be lexical decls in multiple parts of the chain, for the TU
3860  // at least.
3861  // DeclContextOffsets might reallocate as we load additional decls below,
3862  // so make a copy of the vector.
3863  DeclContextInfos Infos = DeclContextOffsets[DC];
3864  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
3865       I != E; ++I) {
3866    // IDs can be 0 if this context doesn't contain declarations.
3867    if (!I->LexicalDecls)
3868      continue;
3869
3870    // Load all of the declaration IDs
3871    for (const KindDeclIDPair *ID = I->LexicalDecls,
3872                              *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
3873      if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
3874        continue;
3875
3876      Decl *D = GetDecl(ID->second);
3877      assert(D && "Null decl in lexical decls");
3878      Decls.push_back(D);
3879    }
3880  }
3881
3882  ++NumLexicalDeclContextsRead;
3883  return false;
3884}
3885
3886DeclContext::lookup_result
3887ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
3888                                          DeclarationName Name) {
3889  assert(DC->hasExternalVisibleStorage() &&
3890         "DeclContext has no visible decls in storage");
3891  if (!Name)
3892    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
3893                                      DeclContext::lookup_iterator(0));
3894
3895  llvm::SmallVector<NamedDecl *, 64> Decls;
3896  // There might be visible decls in multiple parts of the chain, for the TU
3897  // and namespaces. For any given name, the last available results replace
3898  // all earlier ones. For this reason, we walk in reverse.
3899  DeclContextInfos &Infos = DeclContextOffsets[DC];
3900  for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
3901       I != E; ++I) {
3902    if (!I->NameLookupTableData)
3903      continue;
3904
3905    ASTDeclContextNameLookupTable *LookupTable =
3906        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
3907    ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
3908    if (Pos == LookupTable->end())
3909      continue;
3910
3911    ASTDeclContextNameLookupTrait::data_type Data = *Pos;
3912    for (; Data.first != Data.second; ++Data.first)
3913      Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first)));
3914    break;
3915  }
3916
3917  ++NumVisibleDeclContextsRead;
3918
3919  SetExternalVisibleDeclsForName(DC, Name, Decls);
3920  return const_cast<DeclContext*>(DC)->lookup(Name);
3921}
3922
3923void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
3924  assert(DC->hasExternalVisibleStorage() &&
3925         "DeclContext has no visible decls in storage");
3926
3927  llvm::SmallVector<NamedDecl *, 64> Decls;
3928  // There might be visible decls in multiple parts of the chain, for the TU
3929  // and namespaces.
3930  DeclContextInfos &Infos = DeclContextOffsets[DC];
3931  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
3932       I != E; ++I) {
3933    if (!I->NameLookupTableData)
3934      continue;
3935
3936    ASTDeclContextNameLookupTable *LookupTable =
3937        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
3938    for (ASTDeclContextNameLookupTable::item_iterator
3939           ItemI = LookupTable->item_begin(),
3940           ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
3941      ASTDeclContextNameLookupTable::item_iterator::value_type Val
3942          = *ItemI;
3943      ASTDeclContextNameLookupTrait::data_type Data = Val.second;
3944      Decls.clear();
3945      for (; Data.first != Data.second; ++Data.first)
3946        Decls.push_back(cast<NamedDecl>(GetDecl(*Data.first)));
3947      MaterializeVisibleDeclsForName(DC, Val.first, Decls);
3948    }
3949  }
3950}
3951
3952void ASTReader::PassInterestingDeclsToConsumer() {
3953  assert(Consumer);
3954  while (!InterestingDecls.empty()) {
3955    DeclGroupRef DG(InterestingDecls.front());
3956    InterestingDecls.pop_front();
3957    Consumer->HandleInterestingDecl(DG);
3958  }
3959}
3960
3961void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
3962  this->Consumer = Consumer;
3963
3964  if (!Consumer)
3965    return;
3966
3967  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
3968    // Force deserialization of this decl, which will cause it to be queued for
3969    // passing to the consumer.
3970    GetDecl(ExternalDefinitions[I]);
3971  }
3972
3973  PassInterestingDeclsToConsumer();
3974}
3975
3976void ASTReader::PrintStats() {
3977  std::fprintf(stderr, "*** AST File Statistics:\n");
3978
3979  unsigned NumTypesLoaded
3980    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
3981                                      QualType());
3982  unsigned NumDeclsLoaded
3983    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
3984                                      (Decl *)0);
3985  unsigned NumIdentifiersLoaded
3986    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
3987                                            IdentifiersLoaded.end(),
3988                                            (IdentifierInfo *)0);
3989  unsigned NumSelectorsLoaded
3990    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
3991                                          SelectorsLoaded.end(),
3992                                          Selector());
3993
3994  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
3995  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
3996  if (TotalNumSLocEntries)
3997    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
3998                 NumSLocEntriesRead, TotalNumSLocEntries,
3999                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4000  if (!TypesLoaded.empty())
4001    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4002                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4003                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4004  if (!DeclsLoaded.empty())
4005    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4006                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4007                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4008  if (!IdentifiersLoaded.empty())
4009    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4010                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4011                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4012  if (!SelectorsLoaded.empty())
4013    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4014                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4015                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4016  if (TotalNumStatements)
4017    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4018                 NumStatementsRead, TotalNumStatements,
4019                 ((float)NumStatementsRead/TotalNumStatements * 100));
4020  if (TotalNumMacros)
4021    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4022                 NumMacrosRead, TotalNumMacros,
4023                 ((float)NumMacrosRead/TotalNumMacros * 100));
4024  if (TotalLexicalDeclContexts)
4025    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4026                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4027                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4028                  * 100));
4029  if (TotalVisibleDeclContexts)
4030    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4031                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4032                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4033                  * 100));
4034  if (TotalNumMethodPoolEntries) {
4035    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4036                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4037                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4038                  * 100));
4039    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4040  }
4041  std::fprintf(stderr, "\n");
4042}
4043
4044void ASTReader::InitializeSema(Sema &S) {
4045  SemaObj = &S;
4046  S.ExternalSource = this;
4047
4048  // Makes sure any declarations that were deserialized "too early"
4049  // still get added to the identifier's declaration chains.
4050  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4051    if (SemaObj->TUScope)
4052      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4053
4054    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4055  }
4056  PreloadedDecls.clear();
4057
4058  // If there were any tentative definitions, deserialize them and add
4059  // them to Sema's list of tentative definitions.
4060  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4061    VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I]));
4062    SemaObj->TentativeDefinitions.push_back(Var);
4063  }
4064
4065  // If there were any unused file scoped decls, deserialize them and add to
4066  // Sema's list of unused file scoped decls.
4067  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4068    DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4069    SemaObj->UnusedFileScopedDecls.push_back(D);
4070  }
4071
4072  // If there were any locally-scoped external declarations,
4073  // deserialize them and add them to Sema's table of locally-scoped
4074  // external declarations.
4075  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4076    NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4077    SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D;
4078  }
4079
4080  // If there were any ext_vector type declarations, deserialize them
4081  // and add them to Sema's vector of such declarations.
4082  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I)
4083    SemaObj->ExtVectorDecls.push_back(
4084                               cast<TypedefDecl>(GetDecl(ExtVectorDecls[I])));
4085
4086  // FIXME: Do VTable uses and dynamic classes deserialize too much ?
4087  // Can we cut them down before writing them ?
4088
4089  // If there were any dynamic classes declarations, deserialize them
4090  // and add them to Sema's vector of such declarations.
4091  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I)
4092    SemaObj->DynamicClasses.push_back(
4093                               cast<CXXRecordDecl>(GetDecl(DynamicClasses[I])));
4094
4095  // Load the offsets of the declarations that Sema references.
4096  // They will be lazily deserialized when needed.
4097  if (!SemaDeclRefs.empty()) {
4098    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4099    SemaObj->StdNamespace = SemaDeclRefs[0];
4100    SemaObj->StdBadAlloc = SemaDeclRefs[1];
4101  }
4102
4103  for (PerFileData *F = FirstInSource; F; F = F->NextInSource) {
4104
4105    // If there are @selector references added them to its pool. This is for
4106    // implementation of -Wselector.
4107    if (!F->ReferencedSelectorsData.empty()) {
4108      unsigned int DataSize = F->ReferencedSelectorsData.size()-1;
4109      unsigned I = 0;
4110      while (I < DataSize) {
4111        Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]);
4112        SourceLocation SelLoc = ReadSourceLocation(
4113                                    *F, F->ReferencedSelectorsData, I);
4114        SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc));
4115      }
4116    }
4117
4118    // If there were any pending implicit instantiations, deserialize them
4119    // and add them to Sema's queue of such instantiations.
4120    assert(F->PendingInstantiations.size() % 2 == 0 &&
4121           "Expected pairs of entries");
4122    for (unsigned Idx = 0, N = F->PendingInstantiations.size(); Idx < N;) {
4123      ValueDecl *D=cast<ValueDecl>(GetDecl(F->PendingInstantiations[Idx++]));
4124      SourceLocation Loc = ReadSourceLocation(*F, F->PendingInstantiations,Idx);
4125      SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc));
4126    }
4127  }
4128
4129  // The two special data sets below always come from the most recent PCH,
4130  // which is at the front of the chain.
4131  PerFileData &F = *Chain.front();
4132
4133  // If there were any weak undeclared identifiers, deserialize them and add to
4134  // Sema's list of weak undeclared identifiers.
4135  if (!WeakUndeclaredIdentifiers.empty()) {
4136    unsigned Idx = 0;
4137    for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) {
4138      IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4139      IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4140      SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx);
4141      bool Used = WeakUndeclaredIdentifiers[Idx++];
4142      Sema::WeakInfo WI(AliasId, Loc);
4143      WI.setUsed(Used);
4144      SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI));
4145    }
4146  }
4147
4148  // If there were any VTable uses, deserialize the information and add it
4149  // to Sema's vector and map of VTable uses.
4150  if (!VTableUses.empty()) {
4151    unsigned Idx = 0;
4152    for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) {
4153      CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4154      SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx);
4155      bool DefinitionRequired = VTableUses[Idx++];
4156      SemaObj->VTableUses.push_back(std::make_pair(Class, Loc));
4157      SemaObj->VTablesUsed[Class] = DefinitionRequired;
4158    }
4159  }
4160
4161  if (!FPPragmaOptions.empty()) {
4162    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4163    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4164  }
4165
4166  if (!OpenCLExtensions.empty()) {
4167    unsigned I = 0;
4168#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4169#include "clang/Basic/OpenCLExtensions.def"
4170
4171    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4172  }
4173}
4174
4175IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4176  // Try to find this name within our on-disk hash tables. We start with the
4177  // most recent one, since that one contains the most up-to-date info.
4178  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4179    ASTIdentifierLookupTable *IdTable
4180        = (ASTIdentifierLookupTable *)Chain[I]->IdentifierLookupTable;
4181    if (!IdTable)
4182      continue;
4183    std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4184    ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4185    if (Pos == IdTable->end())
4186      continue;
4187
4188    // Dereferencing the iterator has the effect of building the
4189    // IdentifierInfo node and populating it with the various
4190    // declarations it needs.
4191    return *Pos;
4192  }
4193  return 0;
4194}
4195
4196namespace clang {
4197  /// \brief An identifier-lookup iterator that enumerates all of the
4198  /// identifiers stored within a set of AST files.
4199  class ASTIdentifierIterator : public IdentifierIterator {
4200    /// \brief The AST reader whose identifiers are being enumerated.
4201    const ASTReader &Reader;
4202
4203    /// \brief The current index into the chain of AST files stored in
4204    /// the AST reader.
4205    unsigned Index;
4206
4207    /// \brief The current position within the identifier lookup table
4208    /// of the current AST file.
4209    ASTIdentifierLookupTable::key_iterator Current;
4210
4211    /// \brief The end position within the identifier lookup table of
4212    /// the current AST file.
4213    ASTIdentifierLookupTable::key_iterator End;
4214
4215  public:
4216    explicit ASTIdentifierIterator(const ASTReader &Reader);
4217
4218    virtual llvm::StringRef Next();
4219  };
4220}
4221
4222ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4223  : Reader(Reader), Index(Reader.Chain.size() - 1) {
4224  ASTIdentifierLookupTable *IdTable
4225    = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable;
4226  Current = IdTable->key_begin();
4227  End = IdTable->key_end();
4228}
4229
4230llvm::StringRef ASTIdentifierIterator::Next() {
4231  while (Current == End) {
4232    // If we have exhausted all of our AST files, we're done.
4233    if (Index == 0)
4234      return llvm::StringRef();
4235
4236    --Index;
4237    ASTIdentifierLookupTable *IdTable
4238      = (ASTIdentifierLookupTable *)Reader.Chain[Index]->IdentifierLookupTable;
4239    Current = IdTable->key_begin();
4240    End = IdTable->key_end();
4241  }
4242
4243  // We have any identifiers remaining in the current AST file; return
4244  // the next one.
4245  std::pair<const char*, unsigned> Key = *Current;
4246  ++Current;
4247  return llvm::StringRef(Key.first, Key.second);
4248}
4249
4250IdentifierIterator *ASTReader::getIdentifiers() const {
4251  return new ASTIdentifierIterator(*this);
4252}
4253
4254std::pair<ObjCMethodList, ObjCMethodList>
4255ASTReader::ReadMethodPool(Selector Sel) {
4256  // Find this selector in a hash table. We want to find the most recent entry.
4257  for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4258    PerFileData &F = *Chain[I];
4259    if (!F.SelectorLookupTable)
4260      continue;
4261
4262    ASTSelectorLookupTable *PoolTable
4263      = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4264    ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4265    if (Pos != PoolTable->end()) {
4266      ++NumSelectorsRead;
4267      // FIXME: Not quite happy with the statistics here. We probably should
4268      // disable this tracking when called via LoadSelector.
4269      // Also, should entries without methods count as misses?
4270      ++NumMethodPoolEntriesRead;
4271      ASTSelectorLookupTrait::data_type Data = *Pos;
4272      if (DeserializationListener)
4273        DeserializationListener->SelectorRead(Data.ID, Sel);
4274      return std::make_pair(Data.Instance, Data.Factory);
4275    }
4276  }
4277
4278  ++NumMethodPoolMisses;
4279  return std::pair<ObjCMethodList, ObjCMethodList>();
4280}
4281
4282void ASTReader::LoadSelector(Selector Sel) {
4283  // It would be complicated to avoid reading the methods anyway. So don't.
4284  ReadMethodPool(Sel);
4285}
4286
4287void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) {
4288  assert(ID && "Non-zero identifier ID required");
4289  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4290  IdentifiersLoaded[ID - 1] = II;
4291  if (DeserializationListener)
4292    DeserializationListener->IdentifierRead(ID, II);
4293}
4294
4295/// \brief Set the globally-visible declarations associated with the given
4296/// identifier.
4297///
4298/// If the AST reader is currently in a state where the given declaration IDs
4299/// cannot safely be resolved, they are queued until it is safe to resolve
4300/// them.
4301///
4302/// \param II an IdentifierInfo that refers to one or more globally-visible
4303/// declarations.
4304///
4305/// \param DeclIDs the set of declaration IDs with the name @p II that are
4306/// visible at global scope.
4307///
4308/// \param Nonrecursive should be true to indicate that the caller knows that
4309/// this call is non-recursive, and therefore the globally-visible declarations
4310/// will not be placed onto the pending queue.
4311void
4312ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4313                              const llvm::SmallVectorImpl<uint32_t> &DeclIDs,
4314                                   bool Nonrecursive) {
4315  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4316    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4317    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4318    PII.II = II;
4319    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4320    return;
4321  }
4322
4323  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4324    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4325    if (SemaObj) {
4326      if (SemaObj->TUScope) {
4327        // Introduce this declaration into the translation-unit scope
4328        // and add it to the declaration chain for this identifier, so
4329        // that (unqualified) name lookup will find it.
4330        SemaObj->TUScope->AddDecl(D);
4331      }
4332      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4333    } else {
4334      // Queue this declaration so that it will be added to the
4335      // translation unit scope and identifier's declaration chain
4336      // once a Sema object is known.
4337      PreloadedDecls.push_back(D);
4338    }
4339  }
4340}
4341
4342IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) {
4343  if (ID == 0)
4344    return 0;
4345
4346  if (IdentifiersLoaded.empty()) {
4347    Error("no identifier table in AST file");
4348    return 0;
4349  }
4350
4351  assert(PP && "Forgot to set Preprocessor ?");
4352  ID -= 1;
4353  if (!IdentifiersLoaded[ID]) {
4354    unsigned Index = ID;
4355    const char *Str = 0;
4356    for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4357      PerFileData *F = Chain[N - I - 1];
4358      if (Index < F->LocalNumIdentifiers) {
4359         uint32_t Offset = F->IdentifierOffsets[Index];
4360         Str = F->IdentifierTableData + Offset;
4361         break;
4362      }
4363      Index -= F->LocalNumIdentifiers;
4364    }
4365    assert(Str && "Broken Chain");
4366
4367    // All of the strings in the AST file are preceded by a 16-bit length.
4368    // Extract that 16-bit length to avoid having to execute strlen().
4369    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4370    //  unsigned integers.  This is important to avoid integer overflow when
4371    //  we cast them to 'unsigned'.
4372    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4373    unsigned StrLen = (((unsigned) StrLenPtr[0])
4374                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4375    IdentifiersLoaded[ID]
4376      = &PP->getIdentifierTable().get(Str, StrLen);
4377    if (DeserializationListener)
4378      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4379  }
4380
4381  return IdentifiersLoaded[ID];
4382}
4383
4384void ASTReader::ReadSLocEntry(unsigned ID) {
4385  ReadSLocEntryRecord(ID);
4386}
4387
4388Selector ASTReader::DecodeSelector(unsigned ID) {
4389  if (ID == 0)
4390    return Selector();
4391
4392  if (ID > SelectorsLoaded.size()) {
4393    Error("selector ID out of range in AST file");
4394    return Selector();
4395  }
4396
4397  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4398    // Load this selector from the selector table.
4399    unsigned Idx = ID - 1;
4400    for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
4401      PerFileData &F = *Chain[N - I - 1];
4402      if (Idx < F.LocalNumSelectors) {
4403        ASTSelectorLookupTrait Trait(*this);
4404        SelectorsLoaded[ID - 1] =
4405           Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0);
4406        if (DeserializationListener)
4407          DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4408        break;
4409      }
4410      Idx -= F.LocalNumSelectors;
4411    }
4412  }
4413
4414  return SelectorsLoaded[ID - 1];
4415}
4416
4417Selector ASTReader::GetExternalSelector(uint32_t ID) {
4418  return DecodeSelector(ID);
4419}
4420
4421uint32_t ASTReader::GetNumExternalSelectors() {
4422  // ID 0 (the null selector) is considered an external selector.
4423  return getTotalNumSelectors() + 1;
4424}
4425
4426DeclarationName
4427ASTReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) {
4428  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4429  switch (Kind) {
4430  case DeclarationName::Identifier:
4431    return DeclarationName(GetIdentifierInfo(Record, Idx));
4432
4433  case DeclarationName::ObjCZeroArgSelector:
4434  case DeclarationName::ObjCOneArgSelector:
4435  case DeclarationName::ObjCMultiArgSelector:
4436    return DeclarationName(GetSelector(Record, Idx));
4437
4438  case DeclarationName::CXXConstructorName:
4439    return Context->DeclarationNames.getCXXConstructorName(
4440                          Context->getCanonicalType(GetType(Record[Idx++])));
4441
4442  case DeclarationName::CXXDestructorName:
4443    return Context->DeclarationNames.getCXXDestructorName(
4444                          Context->getCanonicalType(GetType(Record[Idx++])));
4445
4446  case DeclarationName::CXXConversionFunctionName:
4447    return Context->DeclarationNames.getCXXConversionFunctionName(
4448                          Context->getCanonicalType(GetType(Record[Idx++])));
4449
4450  case DeclarationName::CXXOperatorName:
4451    return Context->DeclarationNames.getCXXOperatorName(
4452                                       (OverloadedOperatorKind)Record[Idx++]);
4453
4454  case DeclarationName::CXXLiteralOperatorName:
4455    return Context->DeclarationNames.getCXXLiteralOperatorName(
4456                                       GetIdentifierInfo(Record, Idx));
4457
4458  case DeclarationName::CXXUsingDirective:
4459    return DeclarationName::getUsingDirectiveName();
4460  }
4461
4462  // Required to silence GCC warning
4463  return DeclarationName();
4464}
4465
4466void ASTReader::ReadDeclarationNameLoc(PerFileData &F,
4467                                       DeclarationNameLoc &DNLoc,
4468                                       DeclarationName Name,
4469                                      const RecordData &Record, unsigned &Idx) {
4470  switch (Name.getNameKind()) {
4471  case DeclarationName::CXXConstructorName:
4472  case DeclarationName::CXXDestructorName:
4473  case DeclarationName::CXXConversionFunctionName:
4474    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4475    break;
4476
4477  case DeclarationName::CXXOperatorName:
4478    DNLoc.CXXOperatorName.BeginOpNameLoc
4479        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4480    DNLoc.CXXOperatorName.EndOpNameLoc
4481        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4482    break;
4483
4484  case DeclarationName::CXXLiteralOperatorName:
4485    DNLoc.CXXLiteralOperatorName.OpNameLoc
4486        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4487    break;
4488
4489  case DeclarationName::Identifier:
4490  case DeclarationName::ObjCZeroArgSelector:
4491  case DeclarationName::ObjCOneArgSelector:
4492  case DeclarationName::ObjCMultiArgSelector:
4493  case DeclarationName::CXXUsingDirective:
4494    break;
4495  }
4496}
4497
4498void ASTReader::ReadDeclarationNameInfo(PerFileData &F,
4499                                        DeclarationNameInfo &NameInfo,
4500                                      const RecordData &Record, unsigned &Idx) {
4501  NameInfo.setName(ReadDeclarationName(Record, Idx));
4502  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4503  DeclarationNameLoc DNLoc;
4504  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4505  NameInfo.setInfo(DNLoc);
4506}
4507
4508void ASTReader::ReadQualifierInfo(PerFileData &F, QualifierInfo &Info,
4509                                  const RecordData &Record, unsigned &Idx) {
4510  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
4511  unsigned NumTPLists = Record[Idx++];
4512  Info.NumTemplParamLists = NumTPLists;
4513  if (NumTPLists) {
4514    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4515    for (unsigned i=0; i != NumTPLists; ++i)
4516      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4517  }
4518}
4519
4520TemplateName
4521ASTReader::ReadTemplateName(PerFileData &F, const RecordData &Record,
4522                            unsigned &Idx) {
4523  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
4524  switch (Kind) {
4525  case TemplateName::Template:
4526    return TemplateName(cast_or_null<TemplateDecl>(GetDecl(Record[Idx++])));
4527
4528  case TemplateName::OverloadedTemplate: {
4529    unsigned size = Record[Idx++];
4530    UnresolvedSet<8> Decls;
4531    while (size--)
4532      Decls.addDecl(cast<NamedDecl>(GetDecl(Record[Idx++])));
4533
4534    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4535  }
4536
4537  case TemplateName::QualifiedTemplate: {
4538    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
4539    bool hasTemplKeyword = Record[Idx++];
4540    TemplateDecl *Template = cast<TemplateDecl>(GetDecl(Record[Idx++]));
4541    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4542  }
4543
4544  case TemplateName::DependentTemplate: {
4545    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(Record, Idx);
4546    if (Record[Idx++])  // isIdentifier
4547      return Context->getDependentTemplateName(NNS,
4548                                               GetIdentifierInfo(Record, Idx));
4549    return Context->getDependentTemplateName(NNS,
4550                                         (OverloadedOperatorKind)Record[Idx++]);
4551  }
4552
4553  case TemplateName::SubstTemplateTemplateParmPack: {
4554    TemplateTemplateParmDecl *Param
4555      = cast_or_null<TemplateTemplateParmDecl>(GetDecl(Record[Idx++]));
4556    if (!Param)
4557      return TemplateName();
4558
4559    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4560    if (ArgPack.getKind() != TemplateArgument::Pack)
4561      return TemplateName();
4562
4563    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4564  }
4565  }
4566
4567  assert(0 && "Unhandled template name kind!");
4568  return TemplateName();
4569}
4570
4571TemplateArgument
4572ASTReader::ReadTemplateArgument(PerFileData &F,
4573                                const RecordData &Record, unsigned &Idx) {
4574  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4575  switch (Kind) {
4576  case TemplateArgument::Null:
4577    return TemplateArgument();
4578  case TemplateArgument::Type:
4579    return TemplateArgument(GetType(Record[Idx++]));
4580  case TemplateArgument::Declaration:
4581    return TemplateArgument(GetDecl(Record[Idx++]));
4582  case TemplateArgument::Integral: {
4583    llvm::APSInt Value = ReadAPSInt(Record, Idx);
4584    QualType T = GetType(Record[Idx++]);
4585    return TemplateArgument(Value, T);
4586  }
4587  case TemplateArgument::Template:
4588    return TemplateArgument(ReadTemplateName(F, Record, Idx));
4589  case TemplateArgument::TemplateExpansion: {
4590    TemplateName Name = ReadTemplateName(F, Record, Idx);
4591    llvm::Optional<unsigned> NumTemplateExpansions;
4592    if (unsigned NumExpansions = Record[Idx++])
4593      NumTemplateExpansions = NumExpansions - 1;
4594    return TemplateArgument(Name, NumTemplateExpansions);
4595  }
4596  case TemplateArgument::Expression:
4597    return TemplateArgument(ReadExpr(F));
4598  case TemplateArgument::Pack: {
4599    unsigned NumArgs = Record[Idx++];
4600    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
4601    for (unsigned I = 0; I != NumArgs; ++I)
4602      Args[I] = ReadTemplateArgument(F, Record, Idx);
4603    return TemplateArgument(Args, NumArgs);
4604  }
4605  }
4606
4607  assert(0 && "Unhandled template argument kind!");
4608  return TemplateArgument();
4609}
4610
4611TemplateParameterList *
4612ASTReader::ReadTemplateParameterList(PerFileData &F,
4613                                     const RecordData &Record, unsigned &Idx) {
4614  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
4615  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
4616  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
4617
4618  unsigned NumParams = Record[Idx++];
4619  llvm::SmallVector<NamedDecl *, 16> Params;
4620  Params.reserve(NumParams);
4621  while (NumParams--)
4622    Params.push_back(cast<NamedDecl>(GetDecl(Record[Idx++])));
4623
4624  TemplateParameterList* TemplateParams =
4625    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
4626                                  Params.data(), Params.size(), RAngleLoc);
4627  return TemplateParams;
4628}
4629
4630void
4631ASTReader::
4632ReadTemplateArgumentList(llvm::SmallVector<TemplateArgument, 8> &TemplArgs,
4633                         PerFileData &F, const RecordData &Record,
4634                         unsigned &Idx) {
4635  unsigned NumTemplateArgs = Record[Idx++];
4636  TemplArgs.reserve(NumTemplateArgs);
4637  while (NumTemplateArgs--)
4638    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
4639}
4640
4641/// \brief Read a UnresolvedSet structure.
4642void ASTReader::ReadUnresolvedSet(UnresolvedSetImpl &Set,
4643                                  const RecordData &Record, unsigned &Idx) {
4644  unsigned NumDecls = Record[Idx++];
4645  while (NumDecls--) {
4646    NamedDecl *D = cast<NamedDecl>(GetDecl(Record[Idx++]));
4647    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
4648    Set.addDecl(D, AS);
4649  }
4650}
4651
4652CXXBaseSpecifier
4653ASTReader::ReadCXXBaseSpecifier(PerFileData &F,
4654                                const RecordData &Record, unsigned &Idx) {
4655  bool isVirtual = static_cast<bool>(Record[Idx++]);
4656  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
4657  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
4658  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
4659  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
4660  SourceRange Range = ReadSourceRange(F, Record, Idx);
4661  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
4662  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
4663                          EllipsisLoc);
4664  Result.setInheritConstructors(inheritConstructors);
4665  return Result;
4666}
4667
4668std::pair<CXXCtorInitializer **, unsigned>
4669ASTReader::ReadCXXCtorInitializers(PerFileData &F, const RecordData &Record,
4670                                   unsigned &Idx) {
4671  CXXCtorInitializer **CtorInitializers = 0;
4672  unsigned NumInitializers = Record[Idx++];
4673  if (NumInitializers) {
4674    ASTContext &C = *getContext();
4675
4676    CtorInitializers
4677        = new (C) CXXCtorInitializer*[NumInitializers];
4678    for (unsigned i=0; i != NumInitializers; ++i) {
4679      TypeSourceInfo *BaseClassInfo = 0;
4680      bool IsBaseVirtual = false;
4681      FieldDecl *Member = 0;
4682      IndirectFieldDecl *IndirectMember = 0;
4683
4684      bool IsBaseInitializer = Record[Idx++];
4685      if (IsBaseInitializer) {
4686        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
4687        IsBaseVirtual = Record[Idx++];
4688      } else {
4689        bool IsIndirectMemberInitializer = Record[Idx++];
4690        if (IsIndirectMemberInitializer)
4691          IndirectMember = cast<IndirectFieldDecl>(GetDecl(Record[Idx++]));
4692        else
4693          Member = cast<FieldDecl>(GetDecl(Record[Idx++]));
4694      }
4695      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
4696      Expr *Init = ReadExpr(F);
4697      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
4698      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
4699      bool IsWritten = Record[Idx++];
4700      unsigned SourceOrderOrNumArrayIndices;
4701      llvm::SmallVector<VarDecl *, 8> Indices;
4702      if (IsWritten) {
4703        SourceOrderOrNumArrayIndices = Record[Idx++];
4704      } else {
4705        SourceOrderOrNumArrayIndices = Record[Idx++];
4706        Indices.reserve(SourceOrderOrNumArrayIndices);
4707        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
4708          Indices.push_back(cast<VarDecl>(GetDecl(Record[Idx++])));
4709      }
4710
4711      CXXCtorInitializer *BOMInit;
4712      if (IsBaseInitializer) {
4713        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
4714                                             LParenLoc, Init, RParenLoc,
4715                                             MemberOrEllipsisLoc);
4716      } else if (IsWritten) {
4717        if (Member)
4718          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
4719                                               LParenLoc, Init, RParenLoc);
4720        else
4721          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
4722                                               MemberOrEllipsisLoc, LParenLoc,
4723                                               Init, RParenLoc);
4724      } else {
4725        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
4726                                             LParenLoc, Init, RParenLoc,
4727                                             Indices.data(), Indices.size());
4728      }
4729
4730      if (IsWritten)
4731        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
4732      CtorInitializers[i] = BOMInit;
4733    }
4734  }
4735
4736  return std::make_pair(CtorInitializers, NumInitializers);
4737}
4738
4739NestedNameSpecifier *
4740ASTReader::ReadNestedNameSpecifier(const RecordData &Record, unsigned &Idx) {
4741  unsigned N = Record[Idx++];
4742  NestedNameSpecifier *NNS = 0, *Prev = 0;
4743  for (unsigned I = 0; I != N; ++I) {
4744    NestedNameSpecifier::SpecifierKind Kind
4745      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
4746    switch (Kind) {
4747    case NestedNameSpecifier::Identifier: {
4748      IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
4749      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
4750      break;
4751    }
4752
4753    case NestedNameSpecifier::Namespace: {
4754      NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
4755      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
4756      break;
4757    }
4758
4759    case NestedNameSpecifier::NamespaceAlias: {
4760      NamespaceAliasDecl *Alias
4761        = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++]));
4762      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
4763      break;
4764    }
4765
4766    case NestedNameSpecifier::TypeSpec:
4767    case NestedNameSpecifier::TypeSpecWithTemplate: {
4768      const Type *T = GetType(Record[Idx++]).getTypePtrOrNull();
4769      if (!T)
4770        return 0;
4771
4772      bool Template = Record[Idx++];
4773      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
4774      break;
4775    }
4776
4777    case NestedNameSpecifier::Global: {
4778      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
4779      // No associated value, and there can't be a prefix.
4780      break;
4781    }
4782    }
4783    Prev = NNS;
4784  }
4785  return NNS;
4786}
4787
4788NestedNameSpecifierLoc
4789ASTReader::ReadNestedNameSpecifierLoc(PerFileData &F, const RecordData &Record,
4790                                      unsigned &Idx) {
4791  unsigned N = Record[Idx++];
4792  NestedNameSpecifierLocBuilder Builder;
4793  for (unsigned I = 0; I != N; ++I) {
4794    NestedNameSpecifier::SpecifierKind Kind
4795      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
4796    switch (Kind) {
4797    case NestedNameSpecifier::Identifier: {
4798      IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
4799      SourceRange Range = ReadSourceRange(F, Record, Idx);
4800      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
4801      break;
4802    }
4803
4804    case NestedNameSpecifier::Namespace: {
4805      NamespaceDecl *NS = cast<NamespaceDecl>(GetDecl(Record[Idx++]));
4806      SourceRange Range = ReadSourceRange(F, Record, Idx);
4807      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
4808      break;
4809    }
4810
4811    case NestedNameSpecifier::NamespaceAlias: {
4812      NamespaceAliasDecl *Alias
4813        = cast<NamespaceAliasDecl>(GetDecl(Record[Idx++]));
4814      SourceRange Range = ReadSourceRange(F, Record, Idx);
4815      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
4816      break;
4817    }
4818
4819    case NestedNameSpecifier::TypeSpec:
4820    case NestedNameSpecifier::TypeSpecWithTemplate: {
4821      bool Template = Record[Idx++];
4822      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
4823      if (!T)
4824        return NestedNameSpecifierLoc();
4825      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
4826
4827      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
4828      Builder.Extend(*Context,
4829                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
4830                     T->getTypeLoc(), ColonColonLoc);
4831      break;
4832    }
4833
4834    case NestedNameSpecifier::Global: {
4835      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
4836      Builder.MakeGlobal(*Context, ColonColonLoc);
4837      break;
4838    }
4839    }
4840  }
4841
4842  return Builder.getWithLocInContext(*Context);
4843}
4844
4845SourceRange
4846ASTReader::ReadSourceRange(PerFileData &F, const RecordData &Record,
4847                           unsigned &Idx) {
4848  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
4849  SourceLocation end = ReadSourceLocation(F, Record, Idx);
4850  return SourceRange(beg, end);
4851}
4852
4853/// \brief Read an integral value
4854llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
4855  unsigned BitWidth = Record[Idx++];
4856  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
4857  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
4858  Idx += NumWords;
4859  return Result;
4860}
4861
4862/// \brief Read a signed integral value
4863llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
4864  bool isUnsigned = Record[Idx++];
4865  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
4866}
4867
4868/// \brief Read a floating-point value
4869llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
4870  return llvm::APFloat(ReadAPInt(Record, Idx));
4871}
4872
4873// \brief Read a string
4874std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
4875  unsigned Len = Record[Idx++];
4876  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
4877  Idx += Len;
4878  return Result;
4879}
4880
4881VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
4882                                         unsigned &Idx) {
4883  unsigned Major = Record[Idx++];
4884  unsigned Minor = Record[Idx++];
4885  unsigned Subminor = Record[Idx++];
4886  if (Minor == 0)
4887    return VersionTuple(Major);
4888  if (Subminor == 0)
4889    return VersionTuple(Major, Minor - 1);
4890  return VersionTuple(Major, Minor - 1, Subminor - 1);
4891}
4892
4893CXXTemporary *ASTReader::ReadCXXTemporary(const RecordData &Record,
4894                                          unsigned &Idx) {
4895  CXXDestructorDecl *Decl = cast<CXXDestructorDecl>(GetDecl(Record[Idx++]));
4896  return CXXTemporary::Create(*Context, Decl);
4897}
4898
4899DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
4900  return Diag(SourceLocation(), DiagID);
4901}
4902
4903DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
4904  return Diags.Report(Loc, DiagID);
4905}
4906
4907/// \brief Retrieve the identifier table associated with the
4908/// preprocessor.
4909IdentifierTable &ASTReader::getIdentifierTable() {
4910  assert(PP && "Forgot to set Preprocessor ?");
4911  return PP->getIdentifierTable();
4912}
4913
4914/// \brief Record that the given ID maps to the given switch-case
4915/// statement.
4916void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
4917  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
4918  SwitchCaseStmts[ID] = SC;
4919}
4920
4921/// \brief Retrieve the switch-case statement with the given ID.
4922SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
4923  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
4924  return SwitchCaseStmts[ID];
4925}
4926
4927void ASTReader::ClearSwitchCaseIDs() {
4928  SwitchCaseStmts.clear();
4929}
4930
4931void ASTReader::FinishedDeserializing() {
4932  assert(NumCurrentElementsDeserializing &&
4933         "FinishedDeserializing not paired with StartedDeserializing");
4934  if (NumCurrentElementsDeserializing == 1) {
4935    // If any identifiers with corresponding top-level declarations have
4936    // been loaded, load those declarations now.
4937    while (!PendingIdentifierInfos.empty()) {
4938      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
4939                              PendingIdentifierInfos.front().DeclIDs, true);
4940      PendingIdentifierInfos.pop_front();
4941    }
4942
4943    // Ready to load previous declarations of Decls that were delayed.
4944    while (!PendingPreviousDecls.empty()) {
4945      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
4946                                PendingPreviousDecls.front().second);
4947      PendingPreviousDecls.pop_front();
4948    }
4949
4950    // We are not in recursive loading, so it's safe to pass the "interesting"
4951    // decls to the consumer.
4952    if (Consumer)
4953      PassInterestingDeclsToConsumer();
4954
4955    assert(PendingForwardRefs.size() == 0 &&
4956           "Some forward refs did not get linked to the definition!");
4957  }
4958  --NumCurrentElementsDeserializing;
4959}
4960
4961ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
4962                     const char *isysroot, bool DisableValidation,
4963                     bool DisableStatCache)
4964  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
4965    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
4966    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
4967    Consumer(0), isysroot(isysroot), DisableValidation(DisableValidation),
4968    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
4969    NumSLocEntriesRead(0), TotalNumSLocEntries(0), NextSLocOffset(0),
4970    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
4971    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
4972    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
4973    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
4974    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
4975    NumCurrentElementsDeserializing(0)
4976{
4977  RelocatablePCH = false;
4978}
4979
4980ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
4981                     Diagnostic &Diags, const char *isysroot,
4982                     bool DisableValidation, bool DisableStatCache)
4983  : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
4984    Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0),
4985    isysroot(isysroot), DisableValidation(DisableValidation),
4986    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
4987    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
4988    NextSLocOffset(0), NumStatementsRead(0), TotalNumStatements(0),
4989    NumMacrosRead(0), TotalNumMacros(0), NumSelectorsRead(0),
4990    NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
4991    TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
4992    TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
4993    TotalVisibleDeclContexts(0), NumCurrentElementsDeserializing(0) {
4994  RelocatablePCH = false;
4995}
4996
4997ASTReader::~ASTReader() {
4998  for (unsigned i = 0, e = Chain.size(); i != e; ++i)
4999    delete Chain[e - i - 1];
5000  // Delete all visible decl lookup tables
5001  for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5002                                       E = DeclContextOffsets.end();
5003       I != E; ++I) {
5004    for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5005         J != F; ++J) {
5006      if (J->NameLookupTableData)
5007        delete static_cast<ASTDeclContextNameLookupTable*>(
5008            J->NameLookupTableData);
5009    }
5010  }
5011  for (DeclContextVisibleUpdatesPending::iterator
5012           I = PendingVisibleUpdates.begin(),
5013           E = PendingVisibleUpdates.end();
5014       I != E; ++I) {
5015    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5016                                             F = I->second.end();
5017         J != F; ++J)
5018      delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5019  }
5020}
5021
5022ASTReader::PerFileData::PerFileData(ASTFileType Ty)
5023  : Type(Ty), SizeInBits(0), LocalNumSLocEntries(0), SLocOffsets(0), LocalSLocSize(0),
5024    LocalNumIdentifiers(0), IdentifierOffsets(0), IdentifierTableData(0),
5025    IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
5026    MacroDefinitionOffsets(0),
5027    LocalNumHeaderFileInfos(0), HeaderFileInfoTableData(0),
5028    HeaderFileInfoTable(0),
5029    LocalNumSelectors(0), SelectorOffsets(0),
5030    SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5031    DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5032    LocalNumTypes(0), TypeOffsets(0), StatCache(0),
5033    NumPreallocatedPreprocessingEntities(0), NextInSource(0)
5034{}
5035
5036ASTReader::PerFileData::~PerFileData() {
5037  delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5038  delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5039  delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5040}
5041