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