ASTReader.cpp revision 5db255e02fde04cbfec65e4596a217591933a76b 
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      if (Info.NumLexicalDecls)
2822        TU->setHasExternalLexicalStorage();
2823      if (Info.NameLookupTableData)
2824        TU->setHasExternalVisibleStorage();
2825    }
2826  }
2827
2828  // If there's a listener, notify them that we "read" the translation unit.
2829  if (DeserializationListener)
2830    DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, TU);
2831
2832  // Make sure we load the declaration update records for the translation unit,
2833  // if there are any.
2834  loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, TU);
2835
2836  // FIXME: Find a better way to deal with collisions between these
2837  // built-in types. Right now, we just ignore the problem.
2838
2839  // Load the special types.
2840  if (Context->getBuiltinVaListType().isNull()) {
2841    Context->setBuiltinVaListType(
2842      GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2843  }
2844
2845  if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) {
2846    if (Context->ObjCProtoType.isNull())
2847      Context->ObjCProtoType = GetType(Proto);
2848  }
2849
2850  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
2851    if (!Context->CFConstantStringTypeDecl)
2852      Context->setCFConstantStringType(GetType(String));
2853  }
2854
2855  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
2856    QualType FileType = GetType(File);
2857    if (FileType.isNull()) {
2858      Error("FILE type is NULL");
2859      return;
2860    }
2861
2862    if (!Context->FILEDecl) {
2863      if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
2864        Context->setFILEDecl(Typedef->getDecl());
2865      else {
2866        const TagType *Tag = FileType->getAs<TagType>();
2867        if (!Tag) {
2868          Error("Invalid FILE type in AST file");
2869          return;
2870        }
2871        Context->setFILEDecl(Tag->getDecl());
2872      }
2873    }
2874  }
2875
2876  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
2877    QualType Jmp_bufType = GetType(Jmp_buf);
2878    if (Jmp_bufType.isNull()) {
2879      Error("jmp_buf type is NULL");
2880      return;
2881    }
2882
2883    if (!Context->jmp_bufDecl) {
2884      if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
2885        Context->setjmp_bufDecl(Typedef->getDecl());
2886      else {
2887        const TagType *Tag = Jmp_bufType->getAs<TagType>();
2888        if (!Tag) {
2889          Error("Invalid jmp_buf type in AST file");
2890          return;
2891        }
2892        Context->setjmp_bufDecl(Tag->getDecl());
2893      }
2894    }
2895  }
2896
2897  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
2898    QualType Sigjmp_bufType = GetType(Sigjmp_buf);
2899    if (Sigjmp_bufType.isNull()) {
2900      Error("sigjmp_buf type is NULL");
2901      return;
2902    }
2903
2904    if (!Context->sigjmp_bufDecl) {
2905      if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
2906        Context->setsigjmp_bufDecl(Typedef->getDecl());
2907      else {
2908        const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
2909        assert(Tag && "Invalid sigjmp_buf type in AST file");
2910        Context->setsigjmp_bufDecl(Tag->getDecl());
2911      }
2912    }
2913  }
2914
2915  if (unsigned ObjCIdRedef
2916        = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
2917    if (Context->ObjCIdRedefinitionType.isNull())
2918      Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
2919  }
2920
2921  if (unsigned ObjCClassRedef
2922        = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
2923    if (Context->ObjCClassRedefinitionType.isNull())
2924      Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
2925  }
2926
2927  if (unsigned ObjCSelRedef
2928        = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
2929    if (Context->ObjCSelRedefinitionType.isNull())
2930      Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
2931  }
2932
2933  ReadPragmaDiagnosticMappings(Context->getDiagnostics());
2934
2935  // If there were any CUDA special declarations, deserialize them.
2936  if (!CUDASpecialDeclRefs.empty()) {
2937    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2938    Context->setcudaConfigureCallDecl(
2939                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2940  }
2941}
2942
2943/// \brief Retrieve the name of the original source file name
2944/// directly from the AST file, without actually loading the AST
2945/// file.
2946std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2947                                             FileManager &FileMgr,
2948                                             Diagnostic &Diags) {
2949  // Open the AST file.
2950  std::string ErrStr;
2951  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
2952  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2953  if (!Buffer) {
2954    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2955    return std::string();
2956  }
2957
2958  // Initialize the stream
2959  llvm::BitstreamReader StreamFile;
2960  llvm::BitstreamCursor Stream;
2961  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
2962                  (const unsigned char *)Buffer->getBufferEnd());
2963  Stream.init(StreamFile);
2964
2965  // Sniff for the signature.
2966  if (Stream.Read(8) != 'C' ||
2967      Stream.Read(8) != 'P' ||
2968      Stream.Read(8) != 'C' ||
2969      Stream.Read(8) != 'H') {
2970    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
2971    return std::string();
2972  }
2973
2974  RecordData Record;
2975  while (!Stream.AtEndOfStream()) {
2976    unsigned Code = Stream.ReadCode();
2977
2978    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2979      unsigned BlockID = Stream.ReadSubBlockID();
2980
2981      // We only know the AST subblock ID.
2982      switch (BlockID) {
2983      case AST_BLOCK_ID:
2984        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2985          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2986          return std::string();
2987        }
2988        break;
2989
2990      default:
2991        if (Stream.SkipBlock()) {
2992          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2993          return std::string();
2994        }
2995        break;
2996      }
2997      continue;
2998    }
2999
3000    if (Code == llvm::bitc::END_BLOCK) {
3001      if (Stream.ReadBlockEnd()) {
3002        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
3003        return std::string();
3004      }
3005      continue;
3006    }
3007
3008    if (Code == llvm::bitc::DEFINE_ABBREV) {
3009      Stream.ReadAbbrevRecord();
3010      continue;
3011    }
3012
3013    Record.clear();
3014    const char *BlobStart = 0;
3015    unsigned BlobLen = 0;
3016    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
3017          == ORIGINAL_FILE_NAME)
3018      return std::string(BlobStart, BlobLen);
3019  }
3020
3021  return std::string();
3022}
3023
3024/// \brief Parse the record that corresponds to a LangOptions data
3025/// structure.
3026///
3027/// This routine parses the language options from the AST file and then gives
3028/// them to the AST listener if one is set.
3029///
3030/// \returns true if the listener deems the file unacceptable, false otherwise.
3031bool ASTReader::ParseLanguageOptions(
3032                             const SmallVectorImpl<uint64_t> &Record) {
3033  if (Listener) {
3034    LangOptions LangOpts;
3035
3036  #define PARSE_LANGOPT(Option)                  \
3037      LangOpts.Option = Record[Idx];             \
3038      ++Idx
3039
3040    unsigned Idx = 0;
3041    PARSE_LANGOPT(Trigraphs);
3042    PARSE_LANGOPT(BCPLComment);
3043    PARSE_LANGOPT(DollarIdents);
3044    PARSE_LANGOPT(AsmPreprocessor);
3045    PARSE_LANGOPT(GNUMode);
3046    PARSE_LANGOPT(GNUKeywords);
3047    PARSE_LANGOPT(ImplicitInt);
3048    PARSE_LANGOPT(Digraphs);
3049    PARSE_LANGOPT(HexFloats);
3050    PARSE_LANGOPT(C99);
3051    PARSE_LANGOPT(C1X);
3052    PARSE_LANGOPT(Microsoft);
3053    PARSE_LANGOPT(CPlusPlus);
3054    PARSE_LANGOPT(CPlusPlus0x);
3055    PARSE_LANGOPT(CXXOperatorNames);
3056    PARSE_LANGOPT(ObjC1);
3057    PARSE_LANGOPT(ObjC2);
3058    PARSE_LANGOPT(ObjCNonFragileABI);
3059    PARSE_LANGOPT(ObjCNonFragileABI2);
3060    PARSE_LANGOPT(AppleKext);
3061    PARSE_LANGOPT(ObjCDefaultSynthProperties);
3062    PARSE_LANGOPT(ObjCInferRelatedResultType);
3063    PARSE_LANGOPT(NoConstantCFStrings);
3064    PARSE_LANGOPT(PascalStrings);
3065    PARSE_LANGOPT(WritableStrings);
3066    PARSE_LANGOPT(LaxVectorConversions);
3067    PARSE_LANGOPT(AltiVec);
3068    PARSE_LANGOPT(Exceptions);
3069    PARSE_LANGOPT(ObjCExceptions);
3070    PARSE_LANGOPT(CXXExceptions);
3071    PARSE_LANGOPT(SjLjExceptions);
3072    PARSE_LANGOPT(MSBitfields);
3073    PARSE_LANGOPT(NeXTRuntime);
3074    PARSE_LANGOPT(Freestanding);
3075    PARSE_LANGOPT(NoBuiltin);
3076    PARSE_LANGOPT(ThreadsafeStatics);
3077    PARSE_LANGOPT(POSIXThreads);
3078    PARSE_LANGOPT(Blocks);
3079    PARSE_LANGOPT(EmitAllDecls);
3080    PARSE_LANGOPT(MathErrno);
3081    LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
3082                                       Record[Idx++]);
3083    PARSE_LANGOPT(HeinousExtensions);
3084    PARSE_LANGOPT(Optimize);
3085    PARSE_LANGOPT(OptimizeSize);
3086    PARSE_LANGOPT(Static);
3087    PARSE_LANGOPT(PICLevel);
3088    PARSE_LANGOPT(GNUInline);
3089    PARSE_LANGOPT(NoInline);
3090    PARSE_LANGOPT(Deprecated);
3091    PARSE_LANGOPT(AccessControl);
3092    PARSE_LANGOPT(CharIsSigned);
3093    PARSE_LANGOPT(ShortWChar);
3094    PARSE_LANGOPT(ShortEnums);
3095    LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
3096    LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
3097    LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
3098                                   Record[Idx++]);
3099    PARSE_LANGOPT(InstantiationDepth);
3100    PARSE_LANGOPT(OpenCL);
3101    PARSE_LANGOPT(CUDA);
3102    PARSE_LANGOPT(CatchUndefined);
3103    PARSE_LANGOPT(DefaultFPContract);
3104    PARSE_LANGOPT(ElideConstructors);
3105    PARSE_LANGOPT(SpellChecking);
3106    PARSE_LANGOPT(MRTD);
3107    PARSE_LANGOPT(ObjCAutoRefCount);
3108  #undef PARSE_LANGOPT
3109
3110    return Listener->ReadLanguageOptions(LangOpts);
3111  }
3112
3113  return false;
3114}
3115
3116namespace {
3117  /// \brief Visitor used by ASTReader::ReadPreprocessedEntities() to load
3118  /// all of the preprocessed entities within a module.
3119  class ReadPreprocessedEntitiesVisitor {
3120    ASTReader &Reader;
3121
3122  public:
3123    explicit ReadPreprocessedEntitiesVisitor(ASTReader &Reader)
3124      : Reader(Reader) { }
3125
3126    static bool visit(Module &M, bool Preorder, void *UserData) {
3127      if (Preorder)
3128        return false;
3129
3130      ReadPreprocessedEntitiesVisitor *This
3131        = static_cast<ReadPreprocessedEntitiesVisitor *>(UserData);
3132
3133      if (!M.PreprocessorDetailCursor.getBitStreamReader())
3134        return false;
3135
3136      SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
3137      M.PreprocessorDetailCursor.JumpToBit(M.PreprocessorDetailStartOffset);
3138      while (This->Reader.LoadPreprocessedEntity(M)) { }
3139      return false;
3140    }
3141  };
3142}
3143
3144void ASTReader::ReadPreprocessedEntities() {
3145  ReadPreprocessedEntitiesVisitor Visitor(*this);
3146  ModuleMgr.visitDepthFirst(&ReadPreprocessedEntitiesVisitor::visit, &Visitor);
3147}
3148
3149PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
3150  RecordLocation Loc = getLocalBitOffset(Offset);
3151
3152  // Keep track of where we are in the stream, then jump back there
3153  // after reading this entity.
3154  SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
3155  Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
3156  return LoadPreprocessedEntity(*Loc.F);
3157}
3158
3159namespace {
3160  /// \brief Visitor used to search for information about a header file.
3161  class HeaderFileInfoVisitor {
3162    ASTReader &Reader;
3163    const FileEntry *FE;
3164
3165    llvm::Optional<HeaderFileInfo> HFI;
3166
3167  public:
3168    HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE)
3169      : Reader(Reader), FE(FE) { }
3170
3171    static bool visit(Module &M, void *UserData) {
3172      HeaderFileInfoVisitor *This
3173        = static_cast<HeaderFileInfoVisitor *>(UserData);
3174
3175      HeaderFileInfoTrait Trait(This->Reader, M,
3176                                &This->Reader.getPreprocessor().getHeaderSearchInfo(),
3177                                M.HeaderFileFrameworkStrings,
3178                                This->FE->getName());
3179
3180      HeaderFileInfoLookupTable *Table
3181        = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
3182      if (!Table)
3183        return false;
3184
3185      // Look in the on-disk hash table for an entry for this file name.
3186      HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(),
3187                                                            &Trait);
3188      if (Pos == Table->end())
3189        return false;
3190
3191      This->HFI = *Pos;
3192      return true;
3193    }
3194
3195    llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
3196  };
3197}
3198
3199HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3200  HeaderFileInfoVisitor Visitor(*this, FE);
3201  ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
3202  if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) {
3203    if (Listener)
3204      Listener->ReadHeaderFileInfo(*HFI, FE->getUID());
3205    return *HFI;
3206  }
3207
3208  return HeaderFileInfo();
3209}
3210
3211void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3212  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3213    Module &F = *(*I);
3214    unsigned Idx = 0;
3215    while (Idx < F.PragmaDiagMappings.size()) {
3216      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3217      while (1) {
3218        assert(Idx < F.PragmaDiagMappings.size() &&
3219               "Invalid data, didn't find '-1' marking end of diag/map pairs");
3220        if (Idx >= F.PragmaDiagMappings.size()) {
3221          break; // Something is messed up but at least avoid infinite loop in
3222                 // release build.
3223        }
3224        unsigned DiagID = F.PragmaDiagMappings[Idx++];
3225        if (DiagID == (unsigned)-1) {
3226          break; // no more diag/map pairs for this location.
3227        }
3228        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3229        Diag.setDiagnosticMapping(DiagID, Map, Loc);
3230      }
3231    }
3232  }
3233}
3234
3235/// \brief Get the correct cursor and offset for loading a type.
3236ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3237  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
3238  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3239  Module *M = I->second;
3240  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
3241}
3242
3243/// \brief Read and return the type with the given index..
3244///
3245/// The index is the type ID, shifted and minus the number of predefs. This
3246/// routine actually reads the record corresponding to the type at the given
3247/// location. It is a helper routine for GetType, which deals with reading type
3248/// IDs.
3249QualType ASTReader::readTypeRecord(unsigned Index) {
3250  RecordLocation Loc = TypeCursorForIndex(Index);
3251  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3252
3253  // Keep track of where we are in the stream, then jump back there
3254  // after reading this type.
3255  SavedStreamPosition SavedPosition(DeclsCursor);
3256
3257  ReadingKindTracker ReadingKind(Read_Type, *this);
3258
3259  // Note that we are loading a type record.
3260  Deserializing AType(this);
3261
3262  unsigned Idx = 0;
3263  DeclsCursor.JumpToBit(Loc.Offset);
3264  RecordData Record;
3265  unsigned Code = DeclsCursor.ReadCode();
3266  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3267  case TYPE_EXT_QUAL: {
3268    if (Record.size() != 2) {
3269      Error("Incorrect encoding of extended qualifier type");
3270      return QualType();
3271    }
3272    QualType Base = readType(*Loc.F, Record, Idx);
3273    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3274    return Context->getQualifiedType(Base, Quals);
3275  }
3276
3277  case TYPE_COMPLEX: {
3278    if (Record.size() != 1) {
3279      Error("Incorrect encoding of complex type");
3280      return QualType();
3281    }
3282    QualType ElemType = readType(*Loc.F, Record, Idx);
3283    return Context->getComplexType(ElemType);
3284  }
3285
3286  case TYPE_POINTER: {
3287    if (Record.size() != 1) {
3288      Error("Incorrect encoding of pointer type");
3289      return QualType();
3290    }
3291    QualType PointeeType = readType(*Loc.F, Record, Idx);
3292    return Context->getPointerType(PointeeType);
3293  }
3294
3295  case TYPE_BLOCK_POINTER: {
3296    if (Record.size() != 1) {
3297      Error("Incorrect encoding of block pointer type");
3298      return QualType();
3299    }
3300    QualType PointeeType = readType(*Loc.F, Record, Idx);
3301    return Context->getBlockPointerType(PointeeType);
3302  }
3303
3304  case TYPE_LVALUE_REFERENCE: {
3305    if (Record.size() != 2) {
3306      Error("Incorrect encoding of lvalue reference type");
3307      return QualType();
3308    }
3309    QualType PointeeType = readType(*Loc.F, Record, Idx);
3310    return Context->getLValueReferenceType(PointeeType, Record[1]);
3311  }
3312
3313  case TYPE_RVALUE_REFERENCE: {
3314    if (Record.size() != 1) {
3315      Error("Incorrect encoding of rvalue reference type");
3316      return QualType();
3317    }
3318    QualType PointeeType = readType(*Loc.F, Record, Idx);
3319    return Context->getRValueReferenceType(PointeeType);
3320  }
3321
3322  case TYPE_MEMBER_POINTER: {
3323    if (Record.size() != 2) {
3324      Error("Incorrect encoding of member pointer type");
3325      return QualType();
3326    }
3327    QualType PointeeType = readType(*Loc.F, Record, Idx);
3328    QualType ClassType = readType(*Loc.F, Record, Idx);
3329    if (PointeeType.isNull() || ClassType.isNull())
3330      return QualType();
3331
3332    return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3333  }
3334
3335  case TYPE_CONSTANT_ARRAY: {
3336    QualType ElementType = readType(*Loc.F, Record, Idx);
3337    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3338    unsigned IndexTypeQuals = Record[2];
3339    unsigned Idx = 3;
3340    llvm::APInt Size = ReadAPInt(Record, Idx);
3341    return Context->getConstantArrayType(ElementType, Size,
3342                                         ASM, IndexTypeQuals);
3343  }
3344
3345  case TYPE_INCOMPLETE_ARRAY: {
3346    QualType ElementType = readType(*Loc.F, Record, Idx);
3347    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3348    unsigned IndexTypeQuals = Record[2];
3349    return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3350  }
3351
3352  case TYPE_VARIABLE_ARRAY: {
3353    QualType ElementType = readType(*Loc.F, Record, Idx);
3354    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3355    unsigned IndexTypeQuals = Record[2];
3356    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3357    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3358    return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3359                                         ASM, IndexTypeQuals,
3360                                         SourceRange(LBLoc, RBLoc));
3361  }
3362
3363  case TYPE_VECTOR: {
3364    if (Record.size() != 3) {
3365      Error("incorrect encoding of vector type in AST file");
3366      return QualType();
3367    }
3368
3369    QualType ElementType = readType(*Loc.F, Record, Idx);
3370    unsigned NumElements = Record[1];
3371    unsigned VecKind = Record[2];
3372    return Context->getVectorType(ElementType, NumElements,
3373                                  (VectorType::VectorKind)VecKind);
3374  }
3375
3376  case TYPE_EXT_VECTOR: {
3377    if (Record.size() != 3) {
3378      Error("incorrect encoding of extended vector type in AST file");
3379      return QualType();
3380    }
3381
3382    QualType ElementType = readType(*Loc.F, Record, Idx);
3383    unsigned NumElements = Record[1];
3384    return Context->getExtVectorType(ElementType, NumElements);
3385  }
3386
3387  case TYPE_FUNCTION_NO_PROTO: {
3388    if (Record.size() != 6) {
3389      Error("incorrect encoding of no-proto function type");
3390      return QualType();
3391    }
3392    QualType ResultType = readType(*Loc.F, Record, Idx);
3393    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3394                               (CallingConv)Record[4], Record[5]);
3395    return Context->getFunctionNoProtoType(ResultType, Info);
3396  }
3397
3398  case TYPE_FUNCTION_PROTO: {
3399    QualType ResultType = readType(*Loc.F, Record, Idx);
3400
3401    FunctionProtoType::ExtProtoInfo EPI;
3402    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3403                                        /*hasregparm*/ Record[2],
3404                                        /*regparm*/ Record[3],
3405                                        static_cast<CallingConv>(Record[4]),
3406                                        /*produces*/ Record[5]);
3407
3408    unsigned Idx = 6;
3409    unsigned NumParams = Record[Idx++];
3410    SmallVector<QualType, 16> ParamTypes;
3411    for (unsigned I = 0; I != NumParams; ++I)
3412      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3413
3414    EPI.Variadic = Record[Idx++];
3415    EPI.TypeQuals = Record[Idx++];
3416    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3417    ExceptionSpecificationType EST =
3418        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3419    EPI.ExceptionSpecType = EST;
3420    if (EST == EST_Dynamic) {
3421      EPI.NumExceptions = Record[Idx++];
3422      SmallVector<QualType, 2> Exceptions;
3423      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3424        Exceptions.push_back(readType(*Loc.F, Record, Idx));
3425      EPI.Exceptions = Exceptions.data();
3426    } else if (EST == EST_ComputedNoexcept) {
3427      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3428    }
3429    return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3430                                    EPI);
3431  }
3432
3433  case TYPE_UNRESOLVED_USING: {
3434    unsigned Idx = 0;
3435    return Context->getTypeDeclType(
3436                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3437  }
3438
3439  case TYPE_TYPEDEF: {
3440    if (Record.size() != 2) {
3441      Error("incorrect encoding of typedef type");
3442      return QualType();
3443    }
3444    unsigned Idx = 0;
3445    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3446    QualType Canonical = readType(*Loc.F, Record, Idx);
3447    if (!Canonical.isNull())
3448      Canonical = Context->getCanonicalType(Canonical);
3449    return Context->getTypedefType(Decl, Canonical);
3450  }
3451
3452  case TYPE_TYPEOF_EXPR:
3453    return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3454
3455  case TYPE_TYPEOF: {
3456    if (Record.size() != 1) {
3457      Error("incorrect encoding of typeof(type) in AST file");
3458      return QualType();
3459    }
3460    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3461    return Context->getTypeOfType(UnderlyingType);
3462  }
3463
3464  case TYPE_DECLTYPE:
3465    return Context->getDecltypeType(ReadExpr(*Loc.F));
3466
3467  case TYPE_UNARY_TRANSFORM: {
3468    QualType BaseType = readType(*Loc.F, Record, Idx);
3469    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3470    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3471    return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3472  }
3473
3474  case TYPE_AUTO:
3475    return Context->getAutoType(readType(*Loc.F, Record, Idx));
3476
3477  case TYPE_RECORD: {
3478    if (Record.size() != 2) {
3479      Error("incorrect encoding of record type");
3480      return QualType();
3481    }
3482    unsigned Idx = 0;
3483    bool IsDependent = Record[Idx++];
3484    QualType T
3485      = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
3486    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3487    return T;
3488  }
3489
3490  case TYPE_ENUM: {
3491    if (Record.size() != 2) {
3492      Error("incorrect encoding of enum type");
3493      return QualType();
3494    }
3495    unsigned Idx = 0;
3496    bool IsDependent = Record[Idx++];
3497    QualType T
3498      = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3499    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3500    return T;
3501  }
3502
3503  case TYPE_ATTRIBUTED: {
3504    if (Record.size() != 3) {
3505      Error("incorrect encoding of attributed type");
3506      return QualType();
3507    }
3508    QualType modifiedType = readType(*Loc.F, Record, Idx);
3509    QualType equivalentType = readType(*Loc.F, Record, Idx);
3510    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3511    return Context->getAttributedType(kind, modifiedType, equivalentType);
3512  }
3513
3514  case TYPE_PAREN: {
3515    if (Record.size() != 1) {
3516      Error("incorrect encoding of paren type");
3517      return QualType();
3518    }
3519    QualType InnerType = readType(*Loc.F, Record, Idx);
3520    return Context->getParenType(InnerType);
3521  }
3522
3523  case TYPE_PACK_EXPANSION: {
3524    if (Record.size() != 2) {
3525      Error("incorrect encoding of pack expansion type");
3526      return QualType();
3527    }
3528    QualType Pattern = readType(*Loc.F, Record, Idx);
3529    if (Pattern.isNull())
3530      return QualType();
3531    llvm::Optional<unsigned> NumExpansions;
3532    if (Record[1])
3533      NumExpansions = Record[1] - 1;
3534    return Context->getPackExpansionType(Pattern, NumExpansions);
3535  }
3536
3537  case TYPE_ELABORATED: {
3538    unsigned Idx = 0;
3539    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3540    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3541    QualType NamedType = readType(*Loc.F, Record, Idx);
3542    return Context->getElaboratedType(Keyword, NNS, NamedType);
3543  }
3544
3545  case TYPE_OBJC_INTERFACE: {
3546    unsigned Idx = 0;
3547    ObjCInterfaceDecl *ItfD
3548      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3549    return Context->getObjCInterfaceType(ItfD);
3550  }
3551
3552  case TYPE_OBJC_OBJECT: {
3553    unsigned Idx = 0;
3554    QualType Base = readType(*Loc.F, Record, Idx);
3555    unsigned NumProtos = Record[Idx++];
3556    SmallVector<ObjCProtocolDecl*, 4> Protos;
3557    for (unsigned I = 0; I != NumProtos; ++I)
3558      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
3559    return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3560  }
3561
3562  case TYPE_OBJC_OBJECT_POINTER: {
3563    unsigned Idx = 0;
3564    QualType Pointee = readType(*Loc.F, Record, Idx);
3565    return Context->getObjCObjectPointerType(Pointee);
3566  }
3567
3568  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3569    unsigned Idx = 0;
3570    QualType Parm = readType(*Loc.F, Record, Idx);
3571    QualType Replacement = readType(*Loc.F, Record, Idx);
3572    return
3573      Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3574                                            Replacement);
3575  }
3576
3577  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3578    unsigned Idx = 0;
3579    QualType Parm = readType(*Loc.F, Record, Idx);
3580    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3581    return Context->getSubstTemplateTypeParmPackType(
3582                                               cast<TemplateTypeParmType>(Parm),
3583                                                     ArgPack);
3584  }
3585
3586  case TYPE_INJECTED_CLASS_NAME: {
3587    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
3588    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
3589    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3590    // for AST reading, too much interdependencies.
3591    return
3592      QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3593  }
3594
3595  case TYPE_TEMPLATE_TYPE_PARM: {
3596    unsigned Idx = 0;
3597    unsigned Depth = Record[Idx++];
3598    unsigned Index = Record[Idx++];
3599    bool Pack = Record[Idx++];
3600    TemplateTypeParmDecl *D
3601      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
3602    return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
3603  }
3604
3605  case TYPE_DEPENDENT_NAME: {
3606    unsigned Idx = 0;
3607    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3608    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3609    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3610    QualType Canon = readType(*Loc.F, Record, Idx);
3611    if (!Canon.isNull())
3612      Canon = Context->getCanonicalType(Canon);
3613    return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3614  }
3615
3616  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3617    unsigned Idx = 0;
3618    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3619    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3620    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3621    unsigned NumArgs = Record[Idx++];
3622    SmallVector<TemplateArgument, 8> Args;
3623    Args.reserve(NumArgs);
3624    while (NumArgs--)
3625      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3626    return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3627                                                      Args.size(), Args.data());
3628  }
3629
3630  case TYPE_DEPENDENT_SIZED_ARRAY: {
3631    unsigned Idx = 0;
3632
3633    // ArrayType
3634    QualType ElementType = readType(*Loc.F, Record, Idx);
3635    ArrayType::ArraySizeModifier ASM
3636      = (ArrayType::ArraySizeModifier)Record[Idx++];
3637    unsigned IndexTypeQuals = Record[Idx++];
3638
3639    // DependentSizedArrayType
3640    Expr *NumElts = ReadExpr(*Loc.F);
3641    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3642
3643    return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3644                                               IndexTypeQuals, Brackets);
3645  }
3646
3647  case TYPE_TEMPLATE_SPECIALIZATION: {
3648    unsigned Idx = 0;
3649    bool IsDependent = Record[Idx++];
3650    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3651    SmallVector<TemplateArgument, 8> Args;
3652    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3653    QualType Underlying = readType(*Loc.F, Record, Idx);
3654    QualType T;
3655    if (Underlying.isNull())
3656      T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3657                                                          Args.size());
3658    else
3659      T = Context->getTemplateSpecializationType(Name, Args.data(),
3660                                                 Args.size(), Underlying);
3661    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3662    return T;
3663  }
3664  }
3665  // Suppress a GCC warning
3666  return QualType();
3667}
3668
3669class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3670  ASTReader &Reader;
3671  Module &F;
3672  llvm::BitstreamCursor &DeclsCursor;
3673  const ASTReader::RecordData &Record;
3674  unsigned &Idx;
3675
3676  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3677                                    unsigned &I) {
3678    return Reader.ReadSourceLocation(F, R, I);
3679  }
3680
3681  template<typename T>
3682  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3683    return Reader.ReadDeclAs<T>(F, Record, Idx);
3684  }
3685
3686public:
3687  TypeLocReader(ASTReader &Reader, Module &F,
3688                const ASTReader::RecordData &Record, unsigned &Idx)
3689    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3690  { }
3691
3692  // We want compile-time assurance that we've enumerated all of
3693  // these, so unfortunately we have to declare them first, then
3694  // define them out-of-line.
3695#define ABSTRACT_TYPELOC(CLASS, PARENT)
3696#define TYPELOC(CLASS, PARENT) \
3697  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3698#include "clang/AST/TypeLocNodes.def"
3699
3700  void VisitFunctionTypeLoc(FunctionTypeLoc);
3701  void VisitArrayTypeLoc(ArrayTypeLoc);
3702};
3703
3704void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3705  // nothing to do
3706}
3707void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3708  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3709  if (TL.needsExtraLocalData()) {
3710    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3711    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3712    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3713    TL.setModeAttr(Record[Idx++]);
3714  }
3715}
3716void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3717  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3718}
3719void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3720  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3721}
3722void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3723  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3724}
3725void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3726  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3727}
3728void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3729  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3730}
3731void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3732  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3733  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3734}
3735void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3736  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3737  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3738  if (Record[Idx++])
3739    TL.setSizeExpr(Reader.ReadExpr(F));
3740  else
3741    TL.setSizeExpr(0);
3742}
3743void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3744  VisitArrayTypeLoc(TL);
3745}
3746void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3747  VisitArrayTypeLoc(TL);
3748}
3749void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3750  VisitArrayTypeLoc(TL);
3751}
3752void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3753                                            DependentSizedArrayTypeLoc TL) {
3754  VisitArrayTypeLoc(TL);
3755}
3756void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3757                                        DependentSizedExtVectorTypeLoc TL) {
3758  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3759}
3760void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3761  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3762}
3763void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3764  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3765}
3766void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3767  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3768  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3769  TL.setTrailingReturn(Record[Idx++]);
3770  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3771    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
3772  }
3773}
3774void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3775  VisitFunctionTypeLoc(TL);
3776}
3777void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3778  VisitFunctionTypeLoc(TL);
3779}
3780void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3781  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3782}
3783void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3784  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3785}
3786void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3787  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3788  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3789  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3790}
3791void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3792  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3793  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3794  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3795  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3796}
3797void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3798  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3799}
3800void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3801  TL.setKWLoc(ReadSourceLocation(Record, Idx));
3802  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3803  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3804  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3805}
3806void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3807  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3808}
3809void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3810  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3811}
3812void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3813  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3814}
3815void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3816  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3817  if (TL.hasAttrOperand()) {
3818    SourceRange range;
3819    range.setBegin(ReadSourceLocation(Record, Idx));
3820    range.setEnd(ReadSourceLocation(Record, Idx));
3821    TL.setAttrOperandParensRange(range);
3822  }
3823  if (TL.hasAttrExprOperand()) {
3824    if (Record[Idx++])
3825      TL.setAttrExprOperand(Reader.ReadExpr(F));
3826    else
3827      TL.setAttrExprOperand(0);
3828  } else if (TL.hasAttrEnumOperand())
3829    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3830}
3831void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3832  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3833}
3834void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3835                                            SubstTemplateTypeParmTypeLoc TL) {
3836  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3837}
3838void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3839                                          SubstTemplateTypeParmPackTypeLoc TL) {
3840  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3841}
3842void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3843                                           TemplateSpecializationTypeLoc TL) {
3844  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3845  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3846  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3847  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3848    TL.setArgLocInfo(i,
3849        Reader.GetTemplateArgumentLocInfo(F,
3850                                          TL.getTypePtr()->getArg(i).getKind(),
3851                                          Record, Idx));
3852}
3853void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3854  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3855  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3856}
3857void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3858  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3859  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3860}
3861void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3862  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3863}
3864void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3865  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3866  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3867  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3868}
3869void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3870       DependentTemplateSpecializationTypeLoc TL) {
3871  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3872  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3873  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3874  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3875  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3876  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3877    TL.setArgLocInfo(I,
3878        Reader.GetTemplateArgumentLocInfo(F,
3879                                          TL.getTypePtr()->getArg(I).getKind(),
3880                                          Record, Idx));
3881}
3882void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3883  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3884}
3885void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3886  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3887}
3888void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3889  TL.setHasBaseTypeAsWritten(Record[Idx++]);
3890  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3891  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3892  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3893    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3894}
3895void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3896  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3897}
3898
3899TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
3900                                             const RecordData &Record,
3901                                             unsigned &Idx) {
3902  QualType InfoTy = readType(F, Record, Idx);
3903  if (InfoTy.isNull())
3904    return 0;
3905
3906  TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
3907  TypeLocReader TLR(*this, F, Record, Idx);
3908  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
3909    TLR.Visit(TL);
3910  return TInfo;
3911}
3912
3913QualType ASTReader::GetType(TypeID ID) {
3914  unsigned FastQuals = ID & Qualifiers::FastMask;
3915  unsigned Index = ID >> Qualifiers::FastWidth;
3916
3917  if (Index < NUM_PREDEF_TYPE_IDS) {
3918    QualType T;
3919    switch ((PredefinedTypeIDs)Index) {
3920    case PREDEF_TYPE_NULL_ID: return QualType();
3921    case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3922    case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
3923
3924    case PREDEF_TYPE_CHAR_U_ID:
3925    case PREDEF_TYPE_CHAR_S_ID:
3926      // FIXME: Check that the signedness of CharTy is correct!
3927      T = Context->CharTy;
3928      break;
3929
3930    case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
3931    case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
3932    case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
3933    case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
3934    case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
3935    case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
3936    case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
3937    case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
3938    case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
3939    case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
3940    case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
3941    case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
3942    case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
3943    case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
3944    case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
3945    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
3946    case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
3947    case PREDEF_TYPE_BOUND_MEMBER:  T = Context->BoundMemberTy;      break;
3948    case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
3949    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
3950    case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
3951    case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
3952    case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
3953    case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
3954    case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
3955    case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
3956    case PREDEF_TYPE_AUTO_DEDUCT:   T = Context->getAutoDeductType(); break;
3957
3958    case PREDEF_TYPE_AUTO_RREF_DEDUCT:
3959      T = Context->getAutoRRefDeductType();
3960      break;
3961    }
3962
3963    assert(!T.isNull() && "Unknown predefined type");
3964    return T.withFastQualifiers(FastQuals);
3965  }
3966
3967  Index -= NUM_PREDEF_TYPE_IDS;
3968  assert(Index < TypesLoaded.size() && "Type index out-of-range");
3969  if (TypesLoaded[Index].isNull()) {
3970    TypesLoaded[Index] = readTypeRecord(Index);
3971    if (TypesLoaded[Index].isNull())
3972      return QualType();
3973
3974    TypesLoaded[Index]->setFromAST();
3975    if (DeserializationListener)
3976      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
3977                                        TypesLoaded[Index]);
3978  }
3979
3980  return TypesLoaded[Index].withFastQualifiers(FastQuals);
3981}
3982
3983QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
3984  return GetType(getGlobalTypeID(F, LocalID));
3985}
3986
3987serialization::TypeID
3988ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
3989  unsigned FastQuals = LocalID & Qualifiers::FastMask;
3990  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
3991
3992  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
3993    return LocalID;
3994
3995  ContinuousRangeMap<uint32_t, int, 2>::iterator I
3996    = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
3997  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
3998
3999  unsigned GlobalIndex = LocalIndex + I->second;
4000  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
4001}
4002
4003TemplateArgumentLocInfo
4004ASTReader::GetTemplateArgumentLocInfo(Module &F,
4005                                      TemplateArgument::ArgKind Kind,
4006                                      const RecordData &Record,
4007                                      unsigned &Index) {
4008  switch (Kind) {
4009  case TemplateArgument::Expression:
4010    return ReadExpr(F);
4011  case TemplateArgument::Type:
4012    return GetTypeSourceInfo(F, Record, Index);
4013  case TemplateArgument::Template: {
4014    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4015                                                                     Index);
4016    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4017    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4018                                   SourceLocation());
4019  }
4020  case TemplateArgument::TemplateExpansion: {
4021    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4022                                                                     Index);
4023    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4024    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
4025    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4026                                   EllipsisLoc);
4027  }
4028  case TemplateArgument::Null:
4029  case TemplateArgument::Integral:
4030  case TemplateArgument::Declaration:
4031  case TemplateArgument::Pack:
4032    return TemplateArgumentLocInfo();
4033  }
4034  llvm_unreachable("unexpected template argument loc");
4035  return TemplateArgumentLocInfo();
4036}
4037
4038TemplateArgumentLoc
4039ASTReader::ReadTemplateArgumentLoc(Module &F,
4040                                   const RecordData &Record, unsigned &Index) {
4041  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
4042
4043  if (Arg.getKind() == TemplateArgument::Expression) {
4044    if (Record[Index++]) // bool InfoHasSameExpr.
4045      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
4046  }
4047  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
4048                                                             Record, Index));
4049}
4050
4051Decl *ASTReader::GetExternalDecl(uint32_t ID) {
4052  return GetDecl(ID);
4053}
4054
4055uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record,
4056                                          unsigned &Idx){
4057  if (Idx >= Record.size())
4058    return 0;
4059
4060  unsigned LocalID = Record[Idx++];
4061  return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
4062}
4063
4064CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
4065  RecordLocation Loc = getLocalBitOffset(Offset);
4066  llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
4067  SavedStreamPosition SavedPosition(Cursor);
4068  Cursor.JumpToBit(Loc.Offset);
4069  ReadingKindTracker ReadingKind(Read_Decl, *this);
4070  RecordData Record;
4071  unsigned Code = Cursor.ReadCode();
4072  unsigned RecCode = Cursor.ReadRecord(Code, Record);
4073  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
4074    Error("Malformed AST file: missing C++ base specifiers");
4075    return 0;
4076  }
4077
4078  unsigned Idx = 0;
4079  unsigned NumBases = Record[Idx++];
4080  void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
4081  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
4082  for (unsigned I = 0; I != NumBases; ++I)
4083    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
4084  return Bases;
4085}
4086
4087serialization::DeclID
4088ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
4089  if (LocalID < NUM_PREDEF_DECL_IDS)
4090    return LocalID;
4091
4092  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4093    = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
4094  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
4095
4096  return LocalID + I->second;
4097}
4098
4099bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
4100                                   Module &M) const {
4101  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID);
4102  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
4103  return &M == I->second;
4104}
4105
4106Decl *ASTReader::GetDecl(DeclID ID) {
4107  if (ID < NUM_PREDEF_DECL_IDS) {
4108    switch ((PredefinedDeclIDs)ID) {
4109    case PREDEF_DECL_NULL_ID:
4110      return 0;
4111
4112    case PREDEF_DECL_TRANSLATION_UNIT_ID:
4113      assert(Context && "No context available?");
4114      return Context->getTranslationUnitDecl();
4115
4116    case PREDEF_DECL_OBJC_ID_ID:
4117      assert(Context && "No context available?");
4118      return Context->getObjCIdDecl();
4119
4120    case PREDEF_DECL_OBJC_SEL_ID:
4121      assert(Context && "No context available?");
4122      return Context->getObjCSelDecl();
4123
4124    case PREDEF_DECL_OBJC_CLASS_ID:
4125      assert(Context && "No context available?");
4126      return Context->getObjCClassDecl();
4127
4128    case PREDEF_DECL_INT_128_ID:
4129      assert(Context && "No context available?");
4130      return Context->getInt128Decl();
4131
4132    case PREDEF_DECL_UNSIGNED_INT_128_ID:
4133      assert(Context && "No context available?");
4134      return Context->getUInt128Decl();
4135
4136    case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
4137      assert(Context && "No context available?");
4138      return Context->getObjCInstanceTypeDecl();
4139    }
4140
4141    return 0;
4142  }
4143
4144  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
4145
4146  if (Index > DeclsLoaded.size()) {
4147    Error("declaration ID out-of-range for AST file");
4148    return 0;
4149  }
4150
4151if (!DeclsLoaded[Index]) {
4152    ReadDeclRecord(ID);
4153    if (DeserializationListener)
4154      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4155  }
4156
4157  return DeclsLoaded[Index];
4158}
4159
4160serialization::DeclID ASTReader::ReadDeclID(Module &F,
4161                                            const RecordData &Record,
4162                                            unsigned &Idx) {
4163  if (Idx >= Record.size()) {
4164    Error("Corrupted AST file");
4165    return 0;
4166  }
4167
4168  return getGlobalDeclID(F, Record[Idx++]);
4169}
4170
4171/// \brief Resolve the offset of a statement into a statement.
4172///
4173/// This operation will read a new statement from the external
4174/// source each time it is called, and is meant to be used via a
4175/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
4176Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
4177  // Switch case IDs are per Decl.
4178  ClearSwitchCaseIDs();
4179
4180  // Offset here is a global offset across the entire chain.
4181  RecordLocation Loc = getLocalBitOffset(Offset);
4182  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4183  return ReadStmtFromStream(*Loc.F);
4184}
4185
4186namespace {
4187  class FindExternalLexicalDeclsVisitor {
4188    ASTReader &Reader;
4189    const DeclContext *DC;
4190    bool (*isKindWeWant)(Decl::Kind);
4191
4192    SmallVectorImpl<Decl*> &Decls;
4193    bool PredefsVisited[NUM_PREDEF_DECL_IDS];
4194
4195  public:
4196    FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
4197                                    bool (*isKindWeWant)(Decl::Kind),
4198                                    SmallVectorImpl<Decl*> &Decls)
4199      : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
4200    {
4201      for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
4202        PredefsVisited[I] = false;
4203    }
4204
4205    static bool visit(Module &M, bool Preorder, void *UserData) {
4206      if (Preorder)
4207        return false;
4208
4209      FindExternalLexicalDeclsVisitor *This
4210        = static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
4211
4212      Module::DeclContextInfosMap::iterator Info
4213        = M.DeclContextInfos.find(This->DC);
4214      if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
4215        return false;
4216
4217      // Load all of the declaration IDs
4218      for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
4219                               *IDE = ID + Info->second.NumLexicalDecls;
4220           ID != IDE; ++ID) {
4221        if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
4222          continue;
4223
4224        // Don't add predefined declarations to the lexical context more
4225        // than once.
4226        if (ID->second < NUM_PREDEF_DECL_IDS) {
4227          if (This->PredefsVisited[ID->second])
4228            continue;
4229
4230          This->PredefsVisited[ID->second] = true;
4231        }
4232
4233        if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
4234          if (!This->DC->isDeclInLexicalTraversal(D))
4235            This->Decls.push_back(D);
4236        }
4237      }
4238
4239      return false;
4240    }
4241  };
4242}
4243
4244ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4245                                         bool (*isKindWeWant)(Decl::Kind),
4246                                         SmallVectorImpl<Decl*> &Decls) {
4247  // There might be lexical decls in multiple modules, for the TU at
4248  // least. Walk all of the modules in the order they were loaded.
4249  FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
4250  ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor);
4251  ++NumLexicalDeclContextsRead;
4252  return ELR_Success;
4253}
4254
4255namespace {
4256  /// \brief Module visitor used to perform name lookup into a
4257  /// declaration context.
4258  class DeclContextNameLookupVisitor {
4259    ASTReader &Reader;
4260    const DeclContext *DC;
4261    DeclarationName Name;
4262    SmallVectorImpl<NamedDecl *> &Decls;
4263
4264  public:
4265    DeclContextNameLookupVisitor(ASTReader &Reader,
4266                                 const DeclContext *DC, DeclarationName Name,
4267                                 SmallVectorImpl<NamedDecl *> &Decls)
4268      : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { }
4269
4270    static bool visit(Module &M, void *UserData) {
4271      DeclContextNameLookupVisitor *This
4272        = static_cast<DeclContextNameLookupVisitor *>(UserData);
4273
4274      // Check whether we have any visible declaration information for
4275      // this context in this module.
4276      Module::DeclContextInfosMap::iterator Info
4277        = M.DeclContextInfos.find(This->DC);
4278      if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData)
4279        return false;
4280
4281      // Look for this name within this module.
4282      ASTDeclContextNameLookupTable *LookupTable =
4283        (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData;
4284      ASTDeclContextNameLookupTable::iterator Pos
4285        = LookupTable->find(This->Name);
4286      if (Pos == LookupTable->end())
4287        return false;
4288
4289      bool FoundAnything = false;
4290      ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4291      for (; Data.first != Data.second; ++Data.first) {
4292        NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
4293        if (!ND)
4294          continue;
4295
4296        if (ND->getDeclName() != This->Name) {
4297          assert(!This->Name.getCXXNameType().isNull() &&
4298                 "Name mismatch without a type");
4299          continue;
4300        }
4301
4302        // Record this declaration.
4303        FoundAnything = true;
4304        This->Decls.push_back(ND);
4305      }
4306
4307      return FoundAnything;
4308    }
4309  };
4310}
4311
4312DeclContext::lookup_result
4313ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4314                                          DeclarationName Name) {
4315  assert(DC->hasExternalVisibleStorage() &&
4316         "DeclContext has no visible decls in storage");
4317  if (!Name)
4318    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4319                                      DeclContext::lookup_iterator(0));
4320
4321  SmallVector<NamedDecl *, 64> Decls;
4322  DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls);
4323  ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
4324  ++NumVisibleDeclContextsRead;
4325  SetExternalVisibleDeclsForName(DC, Name, Decls);
4326  return const_cast<DeclContext*>(DC)->lookup(Name);
4327}
4328
4329void ASTReader::PassInterestingDeclsToConsumer() {
4330  assert(Consumer);
4331  while (!InterestingDecls.empty()) {
4332    DeclGroupRef DG(InterestingDecls.front());
4333    InterestingDecls.pop_front();
4334    Consumer->HandleInterestingDecl(DG);
4335  }
4336}
4337
4338void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4339  this->Consumer = Consumer;
4340
4341  if (!Consumer)
4342    return;
4343
4344  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4345    // Force deserialization of this decl, which will cause it to be queued for
4346    // passing to the consumer.
4347    GetDecl(ExternalDefinitions[I]);
4348  }
4349
4350  PassInterestingDeclsToConsumer();
4351}
4352
4353void ASTReader::PrintStats() {
4354  std::fprintf(stderr, "*** AST File Statistics:\n");
4355
4356  unsigned NumTypesLoaded
4357    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4358                                      QualType());
4359  unsigned NumDeclsLoaded
4360    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4361                                      (Decl *)0);
4362  unsigned NumIdentifiersLoaded
4363    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4364                                            IdentifiersLoaded.end(),
4365                                            (IdentifierInfo *)0);
4366  unsigned NumSelectorsLoaded
4367    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4368                                          SelectorsLoaded.end(),
4369                                          Selector());
4370
4371  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4372  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4373  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
4374    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4375                 NumSLocEntriesRead, TotalNumSLocEntries,
4376                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4377  if (!TypesLoaded.empty())
4378    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4379                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4380                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4381  if (!DeclsLoaded.empty())
4382    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4383                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4384                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4385  if (!IdentifiersLoaded.empty())
4386    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4387                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4388                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4389  if (!SelectorsLoaded.empty())
4390    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4391                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4392                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4393  if (TotalNumStatements)
4394    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4395                 NumStatementsRead, TotalNumStatements,
4396                 ((float)NumStatementsRead/TotalNumStatements * 100));
4397  if (TotalNumMacros)
4398    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4399                 NumMacrosRead, TotalNumMacros,
4400                 ((float)NumMacrosRead/TotalNumMacros * 100));
4401  if (TotalLexicalDeclContexts)
4402    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4403                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4404                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4405                  * 100));
4406  if (TotalVisibleDeclContexts)
4407    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4408                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4409                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4410                  * 100));
4411  if (TotalNumMethodPoolEntries) {
4412    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4413                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4414                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4415                  * 100));
4416    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4417  }
4418  std::fprintf(stderr, "\n");
4419  dump();
4420  std::fprintf(stderr, "\n");
4421}
4422
4423template<typename Key, typename Module, unsigned InitialCapacity>
4424static void
4425dumpModuleIDMap(StringRef Name,
4426                const ContinuousRangeMap<Key, Module *,
4427                                         InitialCapacity> &Map) {
4428  if (Map.begin() == Map.end())
4429    return;
4430
4431  typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
4432  llvm::errs() << Name << ":\n";
4433  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4434       I != IEnd; ++I) {
4435    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
4436      << "\n";
4437  }
4438}
4439
4440void ASTReader::dump() {
4441  llvm::errs() << "*** PCH/Module Remappings:\n";
4442  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
4443  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
4444  dumpModuleIDMap("Global type map", GlobalTypeMap);
4445  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
4446  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
4447  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
4448  dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap);
4449  dumpModuleIDMap("Global preprocessed entity map",
4450                  GlobalPreprocessedEntityMap);
4451
4452  llvm::errs() << "\n*** PCH/Modules Loaded:";
4453  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
4454                                       MEnd = ModuleMgr.end();
4455       M != MEnd; ++M)
4456    (*M)->dump();
4457}
4458
4459/// Return the amount of memory used by memory buffers, breaking down
4460/// by heap-backed versus mmap'ed memory.
4461void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4462  for (ModuleConstIterator I = ModuleMgr.begin(),
4463      E = ModuleMgr.end(); I != E; ++I) {
4464    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4465      size_t bytes = buf->getBufferSize();
4466      switch (buf->getBufferKind()) {
4467        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4468          sizes.malloc_bytes += bytes;
4469          break;
4470        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4471          sizes.mmap_bytes += bytes;
4472          break;
4473      }
4474    }
4475  }
4476}
4477
4478void ASTReader::InitializeSema(Sema &S) {
4479  SemaObj = &S;
4480  S.ExternalSource = this;
4481
4482  // Makes sure any declarations that were deserialized "too early"
4483  // still get added to the identifier's declaration chains.
4484  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4485    if (SemaObj->TUScope)
4486      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4487
4488    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4489  }
4490  PreloadedDecls.clear();
4491
4492  // Load the offsets of the declarations that Sema references.
4493  // They will be lazily deserialized when needed.
4494  if (!SemaDeclRefs.empty()) {
4495    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4496    if (!SemaObj->StdNamespace)
4497      SemaObj->StdNamespace = SemaDeclRefs[0];
4498    if (!SemaObj->StdBadAlloc)
4499      SemaObj->StdBadAlloc = SemaDeclRefs[1];
4500  }
4501
4502  if (!FPPragmaOptions.empty()) {
4503    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4504    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4505  }
4506
4507  if (!OpenCLExtensions.empty()) {
4508    unsigned I = 0;
4509#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4510#include "clang/Basic/OpenCLExtensions.def"
4511
4512    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4513  }
4514}
4515
4516IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4517  IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart));
4518  ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor);
4519  return Visitor.getIdentifierInfo();
4520}
4521
4522namespace clang {
4523  /// \brief An identifier-lookup iterator that enumerates all of the
4524  /// identifiers stored within a set of AST files.
4525  class ASTIdentifierIterator : public IdentifierIterator {
4526    /// \brief The AST reader whose identifiers are being enumerated.
4527    const ASTReader &Reader;
4528
4529    /// \brief The current index into the chain of AST files stored in
4530    /// the AST reader.
4531    unsigned Index;
4532
4533    /// \brief The current position within the identifier lookup table
4534    /// of the current AST file.
4535    ASTIdentifierLookupTable::key_iterator Current;
4536
4537    /// \brief The end position within the identifier lookup table of
4538    /// the current AST file.
4539    ASTIdentifierLookupTable::key_iterator End;
4540
4541  public:
4542    explicit ASTIdentifierIterator(const ASTReader &Reader);
4543
4544    virtual StringRef Next();
4545  };
4546}
4547
4548ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4549  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4550  ASTIdentifierLookupTable *IdTable
4551    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4552  Current = IdTable->key_begin();
4553  End = IdTable->key_end();
4554}
4555
4556StringRef ASTIdentifierIterator::Next() {
4557  while (Current == End) {
4558    // If we have exhausted all of our AST files, we're done.
4559    if (Index == 0)
4560      return StringRef();
4561
4562    --Index;
4563    ASTIdentifierLookupTable *IdTable
4564      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4565        IdentifierLookupTable;
4566    Current = IdTable->key_begin();
4567    End = IdTable->key_end();
4568  }
4569
4570  // We have any identifiers remaining in the current AST file; return
4571  // the next one.
4572  std::pair<const char*, unsigned> Key = *Current;
4573  ++Current;
4574  return StringRef(Key.first, Key.second);
4575}
4576
4577IdentifierIterator *ASTReader::getIdentifiers() const {
4578  return new ASTIdentifierIterator(*this);
4579}
4580
4581namespace clang { namespace serialization {
4582  class ReadMethodPoolVisitor {
4583    ASTReader &Reader;
4584    Selector Sel;
4585    llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
4586    llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
4587
4588    /// \brief Build an ObjCMethodList from a vector of Objective-C method
4589    /// declarations.
4590    ObjCMethodList
4591    buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const
4592    {
4593      ObjCMethodList List;
4594      ObjCMethodList *Prev = 0;
4595      for (unsigned I = 0, N = Vec.size(); I != N; ++I) {
4596        if (!List.Method) {
4597          // This is the first method, which is the easy case.
4598          List.Method = Vec[I];
4599          Prev = &List;
4600          continue;
4601        }
4602
4603        ObjCMethodList *Mem =
4604          Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>();
4605        Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0);
4606        Prev = Prev->Next;
4607      }
4608
4609      return List;
4610    }
4611
4612  public:
4613    ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel)
4614      : Reader(Reader), Sel(Sel) { }
4615
4616    static bool visit(Module &M, void *UserData) {
4617      ReadMethodPoolVisitor *This
4618        = static_cast<ReadMethodPoolVisitor *>(UserData);
4619
4620      if (!M.SelectorLookupTable)
4621        return false;
4622
4623      ASTSelectorLookupTable *PoolTable
4624        = (ASTSelectorLookupTable*)M.SelectorLookupTable;
4625      ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
4626      if (Pos == PoolTable->end())
4627        return false;
4628
4629      ++This->Reader.NumSelectorsRead;
4630      // FIXME: Not quite happy with the statistics here. We probably should
4631      // disable this tracking when called via LoadSelector.
4632      // Also, should entries without methods count as misses?
4633      ++This->Reader.NumMethodPoolEntriesRead;
4634      ASTSelectorLookupTrait::data_type Data = *Pos;
4635      if (This->Reader.DeserializationListener)
4636        This->Reader.DeserializationListener->SelectorRead(Data.ID,
4637                                                           This->Sel);
4638
4639      This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
4640      This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
4641      return true;
4642    }
4643
4644    /// \brief Retrieve the instance methods found by this visitor.
4645    ObjCMethodList getInstanceMethods() const {
4646      return buildObjCMethodList(InstanceMethods);
4647    }
4648
4649    /// \brief Retrieve the instance methods found by this visitor.
4650    ObjCMethodList getFactoryMethods() const {
4651      return buildObjCMethodList(FactoryMethods);
4652    }
4653  };
4654} } // end namespace clang::serialization
4655
4656std::pair<ObjCMethodList, ObjCMethodList>
4657ASTReader::ReadMethodPool(Selector Sel) {
4658  ReadMethodPoolVisitor Visitor(*this, Sel);
4659  ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
4660  std::pair<ObjCMethodList, ObjCMethodList> Result;
4661  Result.first = Visitor.getInstanceMethods();
4662  Result.second = Visitor.getFactoryMethods();
4663
4664  if (!Result.first.Method && !Result.second.Method)
4665    ++NumMethodPoolMisses;
4666  return Result;
4667}
4668
4669void ASTReader::ReadKnownNamespaces(
4670                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4671  Namespaces.clear();
4672
4673  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4674    if (NamespaceDecl *Namespace
4675                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4676      Namespaces.push_back(Namespace);
4677  }
4678}
4679
4680void ASTReader::ReadTentativeDefinitions(
4681                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
4682  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4683    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4684    if (Var)
4685      TentativeDefs.push_back(Var);
4686  }
4687  TentativeDefinitions.clear();
4688}
4689
4690void ASTReader::ReadUnusedFileScopedDecls(
4691                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4692  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4693    DeclaratorDecl *D
4694      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4695    if (D)
4696      Decls.push_back(D);
4697  }
4698  UnusedFileScopedDecls.clear();
4699}
4700
4701void ASTReader::ReadDelegatingConstructors(
4702                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4703  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4704    CXXConstructorDecl *D
4705      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4706    if (D)
4707      Decls.push_back(D);
4708  }
4709  DelegatingCtorDecls.clear();
4710}
4711
4712void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4713  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4714    TypedefNameDecl *D
4715      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4716    if (D)
4717      Decls.push_back(D);
4718  }
4719  ExtVectorDecls.clear();
4720}
4721
4722void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4723  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4724    CXXRecordDecl *D
4725      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4726    if (D)
4727      Decls.push_back(D);
4728  }
4729  DynamicClasses.clear();
4730}
4731
4732void
4733ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4734  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4735    NamedDecl *D
4736      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4737    if (D)
4738      Decls.push_back(D);
4739  }
4740  LocallyScopedExternalDecls.clear();
4741}
4742
4743void ASTReader::ReadReferencedSelectors(
4744       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4745  if (ReferencedSelectorsData.empty())
4746    return;
4747
4748  // If there are @selector references added them to its pool. This is for
4749  // implementation of -Wselector.
4750  unsigned int DataSize = ReferencedSelectorsData.size()-1;
4751  unsigned I = 0;
4752  while (I < DataSize) {
4753    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4754    SourceLocation SelLoc
4755      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4756    Sels.push_back(std::make_pair(Sel, SelLoc));
4757  }
4758  ReferencedSelectorsData.clear();
4759}
4760
4761void ASTReader::ReadWeakUndeclaredIdentifiers(
4762       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4763  if (WeakUndeclaredIdentifiers.empty())
4764    return;
4765
4766  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4767    IdentifierInfo *WeakId
4768      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4769    IdentifierInfo *AliasId
4770      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4771    SourceLocation Loc
4772      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4773    bool Used = WeakUndeclaredIdentifiers[I++];
4774    WeakInfo WI(AliasId, Loc);
4775    WI.setUsed(Used);
4776    WeakIDs.push_back(std::make_pair(WeakId, WI));
4777  }
4778  WeakUndeclaredIdentifiers.clear();
4779}
4780
4781void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4782  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4783    ExternalVTableUse VT;
4784    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4785    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4786    VT.DefinitionRequired = VTableUses[Idx++];
4787    VTables.push_back(VT);
4788  }
4789
4790  VTableUses.clear();
4791}
4792
4793void ASTReader::ReadPendingInstantiations(
4794       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4795  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4796    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4797    SourceLocation Loc
4798      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4799    Pending.push_back(std::make_pair(D, Loc));
4800  }
4801  PendingInstantiations.clear();
4802}
4803
4804void ASTReader::LoadSelector(Selector Sel) {
4805  // It would be complicated to avoid reading the methods anyway. So don't.
4806  ReadMethodPool(Sel);
4807}
4808
4809void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
4810  assert(ID && "Non-zero identifier ID required");
4811  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4812  IdentifiersLoaded[ID - 1] = II;
4813  if (DeserializationListener)
4814    DeserializationListener->IdentifierRead(ID, II);
4815}
4816
4817/// \brief Set the globally-visible declarations associated with the given
4818/// identifier.
4819///
4820/// If the AST reader is currently in a state where the given declaration IDs
4821/// cannot safely be resolved, they are queued until it is safe to resolve
4822/// them.
4823///
4824/// \param II an IdentifierInfo that refers to one or more globally-visible
4825/// declarations.
4826///
4827/// \param DeclIDs the set of declaration IDs with the name @p II that are
4828/// visible at global scope.
4829///
4830/// \param Nonrecursive should be true to indicate that the caller knows that
4831/// this call is non-recursive, and therefore the globally-visible declarations
4832/// will not be placed onto the pending queue.
4833void
4834ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4835                              const SmallVectorImpl<uint32_t> &DeclIDs,
4836                                   bool Nonrecursive) {
4837  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4838    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4839    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4840    PII.II = II;
4841    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4842    return;
4843  }
4844
4845  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4846    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4847    if (SemaObj) {
4848      if (SemaObj->TUScope) {
4849        // Introduce this declaration into the translation-unit scope
4850        // and add it to the declaration chain for this identifier, so
4851        // that (unqualified) name lookup will find it.
4852        SemaObj->TUScope->AddDecl(D);
4853      }
4854      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4855    } else {
4856      // Queue this declaration so that it will be added to the
4857      // translation unit scope and identifier's declaration chain
4858      // once a Sema object is known.
4859      PreloadedDecls.push_back(D);
4860    }
4861  }
4862}
4863
4864IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
4865  if (ID == 0)
4866    return 0;
4867
4868  if (IdentifiersLoaded.empty()) {
4869    Error("no identifier table in AST file");
4870    return 0;
4871  }
4872
4873  assert(PP && "Forgot to set Preprocessor ?");
4874  ID -= 1;
4875  if (!IdentifiersLoaded[ID]) {
4876    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4877    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4878    Module *M = I->second;
4879    unsigned Index = ID - M->BaseIdentifierID;
4880    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
4881
4882    // All of the strings in the AST file are preceded by a 16-bit length.
4883    // Extract that 16-bit length to avoid having to execute strlen().
4884    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4885    //  unsigned integers.  This is important to avoid integer overflow when
4886    //  we cast them to 'unsigned'.
4887    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4888    unsigned StrLen = (((unsigned) StrLenPtr[0])
4889                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4890    IdentifiersLoaded[ID]
4891      = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
4892    if (DeserializationListener)
4893      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4894  }
4895
4896  return IdentifiersLoaded[ID];
4897}
4898
4899IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4900  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4901}
4902
4903IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4904  if (LocalID < NUM_PREDEF_IDENT_IDS)
4905    return LocalID;
4906
4907  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4908    = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
4909  assert(I != M.IdentifierRemap.end()
4910         && "Invalid index into identifier index remap");
4911
4912  return LocalID + I->second;
4913}
4914
4915bool ASTReader::ReadSLocEntry(int ID) {
4916  return ReadSLocEntryRecord(ID) != Success;
4917}
4918
4919Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4920  return DecodeSelector(getGlobalSelectorID(M, LocalID));
4921}
4922
4923Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
4924  if (ID == 0)
4925    return Selector();
4926
4927  if (ID > SelectorsLoaded.size()) {
4928    Error("selector ID out of range in AST file");
4929    return Selector();
4930  }
4931
4932  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4933    // Load this selector from the selector table.
4934    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4935    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4936    Module &M = *I->second;
4937    ASTSelectorLookupTrait Trait(*this, M);
4938    unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
4939    SelectorsLoaded[ID - 1] =
4940      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
4941    if (DeserializationListener)
4942      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4943  }
4944
4945  return SelectorsLoaded[ID - 1];
4946}
4947
4948Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
4949  return DecodeSelector(ID);
4950}
4951
4952uint32_t ASTReader::GetNumExternalSelectors() {
4953  // ID 0 (the null selector) is considered an external selector.
4954  return getTotalNumSelectors() + 1;
4955}
4956
4957serialization::SelectorID
4958ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const {
4959  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
4960    return LocalID;
4961
4962  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4963    = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
4964  assert(I != M.SelectorRemap.end()
4965         && "Invalid index into identifier index remap");
4966
4967  return LocalID + I->second;
4968}
4969
4970DeclarationName
4971ASTReader::ReadDeclarationName(Module &F,
4972                               const RecordData &Record, unsigned &Idx) {
4973  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4974  switch (Kind) {
4975  case DeclarationName::Identifier:
4976    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
4977
4978  case DeclarationName::ObjCZeroArgSelector:
4979  case DeclarationName::ObjCOneArgSelector:
4980  case DeclarationName::ObjCMultiArgSelector:
4981    return DeclarationName(ReadSelector(F, Record, Idx));
4982
4983  case DeclarationName::CXXConstructorName:
4984    return Context->DeclarationNames.getCXXConstructorName(
4985                          Context->getCanonicalType(readType(F, Record, Idx)));
4986
4987  case DeclarationName::CXXDestructorName:
4988    return Context->DeclarationNames.getCXXDestructorName(
4989                          Context->getCanonicalType(readType(F, Record, Idx)));
4990
4991  case DeclarationName::CXXConversionFunctionName:
4992    return Context->DeclarationNames.getCXXConversionFunctionName(
4993                          Context->getCanonicalType(readType(F, Record, Idx)));
4994
4995  case DeclarationName::CXXOperatorName:
4996    return Context->DeclarationNames.getCXXOperatorName(
4997                                       (OverloadedOperatorKind)Record[Idx++]);
4998
4999  case DeclarationName::CXXLiteralOperatorName:
5000    return Context->DeclarationNames.getCXXLiteralOperatorName(
5001                                       GetIdentifierInfo(F, Record, Idx));
5002
5003  case DeclarationName::CXXUsingDirective:
5004    return DeclarationName::getUsingDirectiveName();
5005  }
5006
5007  // Required to silence GCC warning
5008  return DeclarationName();
5009}
5010
5011void ASTReader::ReadDeclarationNameLoc(Module &F,
5012                                       DeclarationNameLoc &DNLoc,
5013                                       DeclarationName Name,
5014                                      const RecordData &Record, unsigned &Idx) {
5015  switch (Name.getNameKind()) {
5016  case DeclarationName::CXXConstructorName:
5017  case DeclarationName::CXXDestructorName:
5018  case DeclarationName::CXXConversionFunctionName:
5019    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
5020    break;
5021
5022  case DeclarationName::CXXOperatorName:
5023    DNLoc.CXXOperatorName.BeginOpNameLoc
5024        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5025    DNLoc.CXXOperatorName.EndOpNameLoc
5026        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5027    break;
5028
5029  case DeclarationName::CXXLiteralOperatorName:
5030    DNLoc.CXXLiteralOperatorName.OpNameLoc
5031        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5032    break;
5033
5034  case DeclarationName::Identifier:
5035  case DeclarationName::ObjCZeroArgSelector:
5036  case DeclarationName::ObjCOneArgSelector:
5037  case DeclarationName::ObjCMultiArgSelector:
5038  case DeclarationName::CXXUsingDirective:
5039    break;
5040  }
5041}
5042
5043void ASTReader::ReadDeclarationNameInfo(Module &F,
5044                                        DeclarationNameInfo &NameInfo,
5045                                      const RecordData &Record, unsigned &Idx) {
5046  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
5047  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
5048  DeclarationNameLoc DNLoc;
5049  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
5050  NameInfo.setInfo(DNLoc);
5051}
5052
5053void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
5054                                  const RecordData &Record, unsigned &Idx) {
5055  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
5056  unsigned NumTPLists = Record[Idx++];
5057  Info.NumTemplParamLists = NumTPLists;
5058  if (NumTPLists) {
5059    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
5060    for (unsigned i=0; i != NumTPLists; ++i)
5061      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
5062  }
5063}
5064
5065TemplateName
5066ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
5067                            unsigned &Idx) {
5068  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
5069  switch (Kind) {
5070  case TemplateName::Template:
5071      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
5072
5073  case TemplateName::OverloadedTemplate: {
5074    unsigned size = Record[Idx++];
5075    UnresolvedSet<8> Decls;
5076    while (size--)
5077      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
5078
5079    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
5080  }
5081
5082  case TemplateName::QualifiedTemplate: {
5083    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5084    bool hasTemplKeyword = Record[Idx++];
5085    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
5086    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
5087  }
5088
5089  case TemplateName::DependentTemplate: {
5090    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5091    if (Record[Idx++])  // isIdentifier
5092      return Context->getDependentTemplateName(NNS,
5093                                               GetIdentifierInfo(F, Record,
5094                                                                 Idx));
5095    return Context->getDependentTemplateName(NNS,
5096                                         (OverloadedOperatorKind)Record[Idx++]);
5097  }
5098
5099  case TemplateName::SubstTemplateTemplateParm: {
5100    TemplateTemplateParmDecl *param
5101      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5102    if (!param) return TemplateName();
5103    TemplateName replacement = ReadTemplateName(F, Record, Idx);
5104    return Context->getSubstTemplateTemplateParm(param, replacement);
5105  }
5106
5107  case TemplateName::SubstTemplateTemplateParmPack: {
5108    TemplateTemplateParmDecl *Param
5109      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5110    if (!Param)
5111      return TemplateName();
5112
5113    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
5114    if (ArgPack.getKind() != TemplateArgument::Pack)
5115      return TemplateName();
5116
5117    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
5118  }
5119  }
5120
5121  assert(0 && "Unhandled template name kind!");
5122  return TemplateName();
5123}
5124
5125TemplateArgument
5126ASTReader::ReadTemplateArgument(Module &F,
5127                                const RecordData &Record, unsigned &Idx) {
5128  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
5129  switch (Kind) {
5130  case TemplateArgument::Null:
5131    return TemplateArgument();
5132  case TemplateArgument::Type:
5133    return TemplateArgument(readType(F, Record, Idx));
5134  case TemplateArgument::Declaration:
5135    return TemplateArgument(ReadDecl(F, Record, Idx));
5136  case TemplateArgument::Integral: {
5137    llvm::APSInt Value = ReadAPSInt(Record, Idx);
5138    QualType T = readType(F, Record, Idx);
5139    return TemplateArgument(Value, T);
5140  }
5141  case TemplateArgument::Template:
5142    return TemplateArgument(ReadTemplateName(F, Record, Idx));
5143  case TemplateArgument::TemplateExpansion: {
5144    TemplateName Name = ReadTemplateName(F, Record, Idx);
5145    llvm::Optional<unsigned> NumTemplateExpansions;
5146    if (unsigned NumExpansions = Record[Idx++])
5147      NumTemplateExpansions = NumExpansions - 1;
5148    return TemplateArgument(Name, NumTemplateExpansions);
5149  }
5150  case TemplateArgument::Expression:
5151    return TemplateArgument(ReadExpr(F));
5152  case TemplateArgument::Pack: {
5153    unsigned NumArgs = Record[Idx++];
5154    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
5155    for (unsigned I = 0; I != NumArgs; ++I)
5156      Args[I] = ReadTemplateArgument(F, Record, Idx);
5157    return TemplateArgument(Args, NumArgs);
5158  }
5159  }
5160
5161  assert(0 && "Unhandled template argument kind!");
5162  return TemplateArgument();
5163}
5164
5165TemplateParameterList *
5166ASTReader::ReadTemplateParameterList(Module &F,
5167                                     const RecordData &Record, unsigned &Idx) {
5168  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5169  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5170  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
5171
5172  unsigned NumParams = Record[Idx++];
5173  SmallVector<NamedDecl *, 16> Params;
5174  Params.reserve(NumParams);
5175  while (NumParams--)
5176    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
5177
5178  TemplateParameterList* TemplateParams =
5179    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
5180                                  Params.data(), Params.size(), RAngleLoc);
5181  return TemplateParams;
5182}
5183
5184void
5185ASTReader::
5186ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5187                         Module &F, const RecordData &Record,
5188                         unsigned &Idx) {
5189  unsigned NumTemplateArgs = Record[Idx++];
5190  TemplArgs.reserve(NumTemplateArgs);
5191  while (NumTemplateArgs--)
5192    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5193}
5194
5195/// \brief Read a UnresolvedSet structure.
5196void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
5197                                  const RecordData &Record, unsigned &Idx) {
5198  unsigned NumDecls = Record[Idx++];
5199  while (NumDecls--) {
5200    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5201    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5202    Set.addDecl(D, AS);
5203  }
5204}
5205
5206CXXBaseSpecifier
5207ASTReader::ReadCXXBaseSpecifier(Module &F,
5208                                const RecordData &Record, unsigned &Idx) {
5209  bool isVirtual = static_cast<bool>(Record[Idx++]);
5210  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5211  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5212  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5213  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5214  SourceRange Range = ReadSourceRange(F, Record, Idx);
5215  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5216  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5217                          EllipsisLoc);
5218  Result.setInheritConstructors(inheritConstructors);
5219  return Result;
5220}
5221
5222std::pair<CXXCtorInitializer **, unsigned>
5223ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
5224                                   unsigned &Idx) {
5225  CXXCtorInitializer **CtorInitializers = 0;
5226  unsigned NumInitializers = Record[Idx++];
5227  if (NumInitializers) {
5228    ASTContext &C = *getContext();
5229
5230    CtorInitializers
5231        = new (C) CXXCtorInitializer*[NumInitializers];
5232    for (unsigned i=0; i != NumInitializers; ++i) {
5233      TypeSourceInfo *BaseClassInfo = 0;
5234      bool IsBaseVirtual = false;
5235      FieldDecl *Member = 0;
5236      IndirectFieldDecl *IndirectMember = 0;
5237      CXXConstructorDecl *Target = 0;
5238
5239      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5240      switch (Type) {
5241       case CTOR_INITIALIZER_BASE:
5242        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
5243        IsBaseVirtual = Record[Idx++];
5244        break;
5245
5246       case CTOR_INITIALIZER_DELEGATING:
5247        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
5248        break;
5249
5250       case CTOR_INITIALIZER_MEMBER:
5251        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5252        break;
5253
5254       case CTOR_INITIALIZER_INDIRECT_MEMBER:
5255        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
5256        break;
5257      }
5258
5259      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
5260      Expr *Init = ReadExpr(F);
5261      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5262      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
5263      bool IsWritten = Record[Idx++];
5264      unsigned SourceOrderOrNumArrayIndices;
5265      SmallVector<VarDecl *, 8> Indices;
5266      if (IsWritten) {
5267        SourceOrderOrNumArrayIndices = Record[Idx++];
5268      } else {
5269        SourceOrderOrNumArrayIndices = Record[Idx++];
5270        Indices.reserve(SourceOrderOrNumArrayIndices);
5271        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5272          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5273      }
5274
5275      CXXCtorInitializer *BOMInit;
5276      if (Type == CTOR_INITIALIZER_BASE) {
5277        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5278                                             LParenLoc, Init, RParenLoc,
5279                                             MemberOrEllipsisLoc);
5280      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5281        BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5282                                             Target, Init, RParenLoc);
5283      } else if (IsWritten) {
5284        if (Member)
5285          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5286                                               LParenLoc, Init, RParenLoc);
5287        else
5288          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5289                                               MemberOrEllipsisLoc, LParenLoc,
5290                                               Init, RParenLoc);
5291      } else {
5292        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5293                                             LParenLoc, Init, RParenLoc,
5294                                             Indices.data(), Indices.size());
5295      }
5296
5297      if (IsWritten)
5298        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5299      CtorInitializers[i] = BOMInit;
5300    }
5301  }
5302
5303  return std::make_pair(CtorInitializers, NumInitializers);
5304}
5305
5306NestedNameSpecifier *
5307ASTReader::ReadNestedNameSpecifier(Module &F,
5308                                   const RecordData &Record, unsigned &Idx) {
5309  unsigned N = Record[Idx++];
5310  NestedNameSpecifier *NNS = 0, *Prev = 0;
5311  for (unsigned I = 0; I != N; ++I) {
5312    NestedNameSpecifier::SpecifierKind Kind
5313      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5314    switch (Kind) {
5315    case NestedNameSpecifier::Identifier: {
5316      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5317      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5318      break;
5319    }
5320
5321    case NestedNameSpecifier::Namespace: {
5322      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5323      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5324      break;
5325    }
5326
5327    case NestedNameSpecifier::NamespaceAlias: {
5328      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5329      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5330      break;
5331    }
5332
5333    case NestedNameSpecifier::TypeSpec:
5334    case NestedNameSpecifier::TypeSpecWithTemplate: {
5335      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5336      if (!T)
5337        return 0;
5338
5339      bool Template = Record[Idx++];
5340      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5341      break;
5342    }
5343
5344    case NestedNameSpecifier::Global: {
5345      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5346      // No associated value, and there can't be a prefix.
5347      break;
5348    }
5349    }
5350    Prev = NNS;
5351  }
5352  return NNS;
5353}
5354
5355NestedNameSpecifierLoc
5356ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5357                                      unsigned &Idx) {
5358  unsigned N = Record[Idx++];
5359  NestedNameSpecifierLocBuilder Builder;
5360  for (unsigned I = 0; I != N; ++I) {
5361    NestedNameSpecifier::SpecifierKind Kind
5362      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5363    switch (Kind) {
5364    case NestedNameSpecifier::Identifier: {
5365      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5366      SourceRange Range = ReadSourceRange(F, Record, Idx);
5367      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5368      break;
5369    }
5370
5371    case NestedNameSpecifier::Namespace: {
5372      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5373      SourceRange Range = ReadSourceRange(F, Record, Idx);
5374      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5375      break;
5376    }
5377
5378    case NestedNameSpecifier::NamespaceAlias: {
5379      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5380      SourceRange Range = ReadSourceRange(F, Record, Idx);
5381      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5382      break;
5383    }
5384
5385    case NestedNameSpecifier::TypeSpec:
5386    case NestedNameSpecifier::TypeSpecWithTemplate: {
5387      bool Template = Record[Idx++];
5388      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5389      if (!T)
5390        return NestedNameSpecifierLoc();
5391      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5392
5393      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5394      Builder.Extend(*Context,
5395                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5396                     T->getTypeLoc(), ColonColonLoc);
5397      break;
5398    }
5399
5400    case NestedNameSpecifier::Global: {
5401      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5402      Builder.MakeGlobal(*Context, ColonColonLoc);
5403      break;
5404    }
5405    }
5406  }
5407
5408  return Builder.getWithLocInContext(*Context);
5409}
5410
5411SourceRange
5412ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5413                           unsigned &Idx) {
5414  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5415  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5416  return SourceRange(beg, end);
5417}
5418
5419/// \brief Read an integral value
5420llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5421  unsigned BitWidth = Record[Idx++];
5422  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5423  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5424  Idx += NumWords;
5425  return Result;
5426}
5427
5428/// \brief Read a signed integral value
5429llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5430  bool isUnsigned = Record[Idx++];
5431  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5432}
5433
5434/// \brief Read a floating-point value
5435llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5436  return llvm::APFloat(ReadAPInt(Record, Idx));
5437}
5438
5439// \brief Read a string
5440std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5441  unsigned Len = Record[Idx++];
5442  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5443  Idx += Len;
5444  return Result;
5445}
5446
5447VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5448                                         unsigned &Idx) {
5449  unsigned Major = Record[Idx++];
5450  unsigned Minor = Record[Idx++];
5451  unsigned Subminor = Record[Idx++];
5452  if (Minor == 0)
5453    return VersionTuple(Major);
5454  if (Subminor == 0)
5455    return VersionTuple(Major, Minor - 1);
5456  return VersionTuple(Major, Minor - 1, Subminor - 1);
5457}
5458
5459CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5460                                          const RecordData &Record,
5461                                          unsigned &Idx) {
5462  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5463  return CXXTemporary::Create(*Context, Decl);
5464}
5465
5466DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5467  return Diag(SourceLocation(), DiagID);
5468}
5469
5470DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5471  return Diags.Report(Loc, DiagID);
5472}
5473
5474/// \brief Retrieve the identifier table associated with the
5475/// preprocessor.
5476IdentifierTable &ASTReader::getIdentifierTable() {
5477  assert(PP && "Forgot to set Preprocessor ?");
5478  return PP->getIdentifierTable();
5479}
5480
5481/// \brief Record that the given ID maps to the given switch-case
5482/// statement.
5483void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5484  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5485  SwitchCaseStmts[ID] = SC;
5486}
5487
5488/// \brief Retrieve the switch-case statement with the given ID.
5489SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5490  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5491  return SwitchCaseStmts[ID];
5492}
5493
5494void ASTReader::ClearSwitchCaseIDs() {
5495  SwitchCaseStmts.clear();
5496}
5497
5498void ASTReader::FinishedDeserializing() {
5499  assert(NumCurrentElementsDeserializing &&
5500         "FinishedDeserializing not paired with StartedDeserializing");
5501  if (NumCurrentElementsDeserializing == 1) {
5502    // If any identifiers with corresponding top-level declarations have
5503    // been loaded, load those declarations now.
5504    while (!PendingIdentifierInfos.empty()) {
5505      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5506                              PendingIdentifierInfos.front().DeclIDs, true);
5507      PendingIdentifierInfos.pop_front();
5508    }
5509
5510    // Ready to load previous declarations of Decls that were delayed.
5511    while (!PendingPreviousDecls.empty()) {
5512      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5513                                PendingPreviousDecls.front().second);
5514      PendingPreviousDecls.pop_front();
5515    }
5516
5517    // We are not in recursive loading, so it's safe to pass the "interesting"
5518    // decls to the consumer.
5519    if (Consumer)
5520      PassInterestingDeclsToConsumer();
5521
5522    assert(PendingForwardRefs.size() == 0 &&
5523           "Some forward refs did not get linked to the definition!");
5524  }
5525  --NumCurrentElementsDeserializing;
5526}
5527
5528ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context,
5529                     StringRef isysroot, bool DisableValidation,
5530                     bool DisableStatCache)
5531  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5532    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5533    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(&Context),
5534    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5535    RelocatablePCH(false), isysroot(isysroot),
5536    DisableValidation(DisableValidation),
5537    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5538    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5539    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5540    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5541    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5542    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5543    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5544    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5545    NumCXXBaseSpecifiersLoaded(0)
5546{
5547  SourceMgr.setExternalSLocEntrySource(this);
5548}
5549
5550ASTReader::~ASTReader() {
5551  for (DeclContextVisibleUpdatesPending::iterator
5552           I = PendingVisibleUpdates.begin(),
5553           E = PendingVisibleUpdates.end();
5554       I != E; ++I) {
5555    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5556                                             F = I->second.end();
5557         J != F; ++J)
5558      delete static_cast<ASTDeclContextNameLookupTable*>(J->first);
5559  }
5560}
5561