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