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