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