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