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