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