ASTReader.cpp revision 10bc00fd45824f9b5cd139d63af8b0f6d28aadda 
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 IMPORTS: {
2037      // Load each of the imported PCH files.
2038      unsigned Idx = 0, N = Record.size();
2039      while (Idx < N) {
2040        // Read information about the AST file.
2041        ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2042        unsigned Length = Record[Idx++];
2043        llvm::SmallString<128> ImportedFile(Record.begin() + Idx,
2044                                            Record.begin() + Idx + Length);
2045        Idx += Length;
2046
2047        // Load the AST file.
2048        switch(ReadASTCore(ImportedFile, ImportedKind, &F)) {
2049        case Failure: return Failure;
2050          // If we have to ignore the dependency, we'll have to ignore this too.
2051        case IgnorePCH: return IgnorePCH;
2052        case Success: break;
2053        }
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(
2095          std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2096
2097        // Introduce the local -> global mapping for declarations within this
2098        // module.
2099        F.DeclRemap.insert(std::make_pair(LocalBaseDeclID,
2100                                          F.BaseDeclID - LocalBaseDeclID));
2101
2102        DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2103      }
2104      break;
2105    }
2106
2107    case TU_UPDATE_LEXICAL: {
2108      DeclContextInfo Info = {
2109        &F,
2110        /* No visible information */ 0,
2111        reinterpret_cast<const KindDeclIDPair *>(BlobStart),
2112        static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair))
2113      };
2114
2115      DeclContext *TU = Context ? Context->getTranslationUnitDecl() : 0;
2116      DeclContextOffsets[TU].push_back(Info);
2117      if (TU)
2118        TU->setHasExternalLexicalStorage(true);
2119
2120      break;
2121    }
2122
2123    case UPDATE_VISIBLE: {
2124      unsigned Idx = 0;
2125      serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2126      void *Table = ASTDeclContextNameLookupTable::Create(
2127                        (const unsigned char *)BlobStart + Record[Idx++],
2128                        (const unsigned char *)BlobStart,
2129                        ASTDeclContextNameLookupTrait(*this, F));
2130      // FIXME: Complete hack to check for the TU
2131      if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID && Context) { // Is it the TU?
2132        DeclContextInfo Info = {
2133          &F, Table, /* No lexical information */ 0, 0
2134        };
2135
2136        DeclContext *TU = Context->getTranslationUnitDecl();
2137        DeclContextOffsets[TU].push_back(Info);
2138        TU->setHasExternalVisibleStorage(true);
2139      } else
2140        PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F));
2141      break;
2142    }
2143
2144    case REDECLS_UPDATE_LATEST: {
2145      assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
2146      for (unsigned i = 0, e = Record.size(); i < e; /* in loop */) {
2147        DeclID First = ReadDeclID(F, Record, i);
2148        DeclID Latest = ReadDeclID(F, Record, i);
2149        FirstLatestDeclIDs[First] = Latest;
2150      }
2151      break;
2152    }
2153
2154    case LANGUAGE_OPTIONS:
2155      if (ParseLanguageOptions(Record) && !DisableValidation)
2156        return IgnorePCH;
2157      break;
2158
2159    case IDENTIFIER_TABLE:
2160      F.IdentifierTableData = BlobStart;
2161      if (Record[0]) {
2162        F.IdentifierLookupTable
2163          = ASTIdentifierLookupTable::Create(
2164                       (const unsigned char *)F.IdentifierTableData + Record[0],
2165                       (const unsigned char *)F.IdentifierTableData,
2166                       ASTIdentifierLookupTrait(*this, F));
2167        if (PP) {
2168          PP->getIdentifierTable().setExternalIdentifierLookup(this);
2169          PP->getHeaderSearchInfo().SetExternalLookup(this);
2170        }
2171      }
2172      break;
2173
2174    case IDENTIFIER_OFFSET: {
2175      if (F.LocalNumIdentifiers != 0) {
2176        Error("duplicate IDENTIFIER_OFFSET record in AST file");
2177        return Failure;
2178      }
2179      F.IdentifierOffsets = (const uint32_t *)BlobStart;
2180      F.LocalNumIdentifiers = Record[0];
2181      unsigned LocalBaseIdentifierID = Record[1];
2182      F.BaseIdentifierID = getTotalNumIdentifiers();
2183
2184      if (F.LocalNumIdentifiers > 0) {
2185        // Introduce the global -> local mapping for identifiers within this
2186        // module.
2187        GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2188                                                  &F));
2189
2190        // Introduce the local -> global mapping for identifiers within this
2191        // module.
2192        F.IdentifierRemap.insert(
2193                            std::make_pair(LocalBaseIdentifierID,
2194                              F.BaseIdentifierID - LocalBaseIdentifierID));
2195
2196        IdentifiersLoaded.resize(IdentifiersLoaded.size()
2197                                 + F.LocalNumIdentifiers);
2198      }
2199      break;
2200    }
2201
2202    case EXTERNAL_DEFINITIONS:
2203      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2204        ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2205      break;
2206
2207    case SPECIAL_TYPES:
2208      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2209        SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2210      break;
2211
2212    case STATISTICS:
2213      TotalNumStatements += Record[0];
2214      TotalNumMacros += Record[1];
2215      TotalLexicalDeclContexts += Record[2];
2216      TotalVisibleDeclContexts += Record[3];
2217      break;
2218
2219    case UNUSED_FILESCOPED_DECLS:
2220      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2221        UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2222      break;
2223
2224    case DELEGATING_CTORS:
2225      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2226        DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2227      break;
2228
2229    case WEAK_UNDECLARED_IDENTIFIERS:
2230      if (Record.size() % 4 != 0) {
2231        Error("invalid weak identifiers record");
2232        return Failure;
2233      }
2234
2235      // FIXME: Ignore weak undeclared identifiers from non-original PCH
2236      // files. This isn't the way to do it :)
2237      WeakUndeclaredIdentifiers.clear();
2238
2239      // Translate the weak, undeclared identifiers into global IDs.
2240      for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2241        WeakUndeclaredIdentifiers.push_back(
2242          getGlobalIdentifierID(F, Record[I++]));
2243        WeakUndeclaredIdentifiers.push_back(
2244          getGlobalIdentifierID(F, Record[I++]));
2245        WeakUndeclaredIdentifiers.push_back(
2246          ReadSourceLocation(F, Record, I).getRawEncoding());
2247        WeakUndeclaredIdentifiers.push_back(Record[I++]);
2248      }
2249      break;
2250
2251    case LOCALLY_SCOPED_EXTERNAL_DECLS:
2252      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2253        LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
2254      break;
2255
2256    case SELECTOR_OFFSETS: {
2257      F.SelectorOffsets = (const uint32_t *)BlobStart;
2258      F.LocalNumSelectors = Record[0];
2259      unsigned LocalBaseSelectorID = Record[1];
2260      F.BaseSelectorID = getTotalNumSelectors();
2261
2262      if (F.LocalNumSelectors > 0) {
2263        // Introduce the global -> local mapping for selectors within this
2264        // module.
2265        GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2266
2267        // Introduce the local -> global mapping for selectors within this
2268        // module.
2269        F.SelectorRemap.insert(std::make_pair(LocalBaseSelectorID,
2270                                 F.BaseSelectorID - LocalBaseSelectorID));
2271
2272        SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2273      }
2274      break;
2275    }
2276
2277    case METHOD_POOL:
2278      F.SelectorLookupTableData = (const unsigned char *)BlobStart;
2279      if (Record[0])
2280        F.SelectorLookupTable
2281          = ASTSelectorLookupTable::Create(
2282                        F.SelectorLookupTableData + Record[0],
2283                        F.SelectorLookupTableData,
2284                        ASTSelectorLookupTrait(*this, F));
2285      TotalNumMethodPoolEntries += Record[1];
2286      break;
2287
2288    case REFERENCED_SELECTOR_POOL:
2289      if (!Record.empty()) {
2290        for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2291          ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2292                                                                Record[Idx++]));
2293          ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2294                                              getRawEncoding());
2295        }
2296      }
2297      break;
2298
2299    case PP_COUNTER_VALUE:
2300      if (!Record.empty() && Listener)
2301        Listener->ReadCounter(Record[0]);
2302      break;
2303
2304    case SOURCE_LOCATION_OFFSETS: {
2305      F.SLocEntryOffsets = (const uint32_t *)BlobStart;
2306      F.LocalNumSLocEntries = Record[0];
2307      llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2308          SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]);
2309      // Make our entry in the range map. BaseID is negative and growing, so
2310      // we invert it. Because we invert it, though, we need the other end of
2311      // the range.
2312      unsigned RangeStart =
2313          unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2314      GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2315      F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2316
2317      // Initialize the remapping table.
2318      // Invalid stays invalid.
2319      F.SLocRemap.insert(std::make_pair(0U, 0));
2320      // This module. Base was 2 when being compiled.
2321      F.SLocRemap.insert(std::make_pair(2U,
2322                                  static_cast<int>(F.SLocEntryBaseOffset - 2)));
2323
2324      TotalNumSLocEntries += F.LocalNumSLocEntries;
2325      break;
2326    }
2327
2328    case MODULE_OFFSET_MAP: {
2329      // Additional remapping information.
2330      const unsigned char *Data = (const unsigned char*)BlobStart;
2331      const unsigned char *DataEnd = Data + BlobLen;
2332
2333      // Continuous range maps we may be updating in our module.
2334      ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap);
2335      ContinuousRangeMap<uint32_t, int, 2>::Builder
2336        IdentifierRemap(F.IdentifierRemap);
2337      ContinuousRangeMap<uint32_t, int, 2>::Builder
2338        PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2339      ContinuousRangeMap<uint32_t, int, 2>::Builder
2340        MacroDefinitionRemap(F.MacroDefinitionRemap);
2341      ContinuousRangeMap<uint32_t, int, 2>::Builder
2342        SelectorRemap(F.SelectorRemap);
2343      ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap);
2344      ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap);
2345
2346      while(Data < DataEnd) {
2347        uint16_t Len = io::ReadUnalignedLE16(Data);
2348        StringRef Name = StringRef((const char*)Data, Len);
2349        Data += Len;
2350        Module *OM = ModuleMgr.lookup(Name);
2351        if (!OM) {
2352          Error("SourceLocation remap refers to unknown module");
2353          return Failure;
2354        }
2355
2356        uint32_t SLocOffset = io::ReadUnalignedLE32(Data);
2357        uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data);
2358        uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data);
2359        uint32_t MacroDefinitionIDOffset = io::ReadUnalignedLE32(Data);
2360        uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data);
2361        uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data);
2362        uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data);
2363
2364        // Source location offset is mapped to OM->SLocEntryBaseOffset.
2365        SLocRemap.insert(std::make_pair(SLocOffset,
2366          static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset)));
2367        IdentifierRemap.insert(
2368          std::make_pair(IdentifierIDOffset,
2369                         OM->BaseIdentifierID - IdentifierIDOffset));
2370        PreprocessedEntityRemap.insert(
2371          std::make_pair(PreprocessedEntityIDOffset,
2372            OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset));
2373        MacroDefinitionRemap.insert(
2374          std::make_pair(MacroDefinitionIDOffset,
2375                         OM->BaseMacroDefinitionID - MacroDefinitionIDOffset));
2376        SelectorRemap.insert(std::make_pair(SelectorIDOffset,
2377                               OM->BaseSelectorID - SelectorIDOffset));
2378        DeclRemap.insert(std::make_pair(DeclIDOffset,
2379                                        OM->BaseDeclID - DeclIDOffset));
2380
2381        TypeRemap.insert(std::make_pair(TypeIndexOffset,
2382                                    OM->BaseTypeIndex - TypeIndexOffset));
2383      }
2384      break;
2385    }
2386
2387    case SOURCE_MANAGER_LINE_TABLE:
2388      if (ParseLineTable(F, Record))
2389        return Failure;
2390      break;
2391
2392    case FILE_SOURCE_LOCATION_OFFSETS:
2393      F.SLocFileOffsets = (const uint32_t *)BlobStart;
2394      F.LocalNumSLocFileEntries = Record[0];
2395      break;
2396
2397    case SOURCE_LOCATION_PRELOADS: {
2398      // Need to transform from the local view (1-based IDs) to the global view,
2399      // which is based off F.SLocEntryBaseID.
2400      PreloadSLocEntries.reserve(PreloadSLocEntries.size() + Record.size());
2401      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2402        PreloadSLocEntries.push_back(int(Record[I] - 1) + F.SLocEntryBaseID);
2403      break;
2404    }
2405
2406    case STAT_CACHE: {
2407      if (!DisableStatCache) {
2408        ASTStatCache *MyStatCache =
2409          new ASTStatCache((const unsigned char *)BlobStart + Record[0],
2410                           (const unsigned char *)BlobStart,
2411                           NumStatHits, NumStatMisses);
2412        FileMgr.addStatCache(MyStatCache);
2413        F.StatCache = MyStatCache;
2414      }
2415      break;
2416    }
2417
2418    case EXT_VECTOR_DECLS:
2419      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2420        ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2421      break;
2422
2423    case VTABLE_USES:
2424      if (Record.size() % 3 != 0) {
2425        Error("Invalid VTABLE_USES record");
2426        return Failure;
2427      }
2428
2429      // Later tables overwrite earlier ones.
2430      // FIXME: Modules will have some trouble with this. This is clearly not
2431      // the right way to do this.
2432      VTableUses.clear();
2433
2434      for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2435        VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2436        VTableUses.push_back(
2437          ReadSourceLocation(F, Record, Idx).getRawEncoding());
2438        VTableUses.push_back(Record[Idx++]);
2439      }
2440      break;
2441
2442    case DYNAMIC_CLASSES:
2443      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2444        DynamicClasses.push_back(getGlobalDeclID(F, Record[I]));
2445      break;
2446
2447    case PENDING_IMPLICIT_INSTANTIATIONS:
2448      if (PendingInstantiations.size() % 2 != 0) {
2449        Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2450        return Failure;
2451      }
2452
2453      // Later lists of pending instantiations overwrite earlier ones.
2454      // FIXME: This is most certainly wrong for modules.
2455      PendingInstantiations.clear();
2456      for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2457        PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2458        PendingInstantiations.push_back(
2459          ReadSourceLocation(F, Record, I).getRawEncoding());
2460      }
2461      break;
2462
2463    case SEMA_DECL_REFS:
2464      // Later tables overwrite earlier ones.
2465      // FIXME: Modules will have some trouble with this.
2466      SemaDeclRefs.clear();
2467      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2468        SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2469      break;
2470
2471    case ORIGINAL_FILE_NAME:
2472      // The primary AST will be the last to get here, so it will be the one
2473      // that's used.
2474      ActualOriginalFileName.assign(BlobStart, BlobLen);
2475      OriginalFileName = ActualOriginalFileName;
2476      MaybeAddSystemRootToFilename(OriginalFileName);
2477      break;
2478
2479    case ORIGINAL_FILE_ID:
2480      OriginalFileID = FileID::get(Record[0]);
2481      break;
2482
2483    case ORIGINAL_PCH_DIR:
2484      // The primary AST will be the last to get here, so it will be the one
2485      // that's used.
2486      OriginalDir.assign(BlobStart, BlobLen);
2487      break;
2488
2489    case VERSION_CONTROL_BRANCH_REVISION: {
2490      const std::string &CurBranch = getClangFullRepositoryVersion();
2491      StringRef ASTBranch(BlobStart, BlobLen);
2492      if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2493        Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch;
2494        return IgnorePCH;
2495      }
2496      break;
2497    }
2498
2499    case MACRO_DEFINITION_OFFSETS: {
2500      F.MacroDefinitionOffsets = (const uint32_t *)BlobStart;
2501      F.NumPreallocatedPreprocessingEntities = Record[0];
2502      unsigned LocalBasePreprocessedEntityID = Record[1];
2503      F.LocalNumMacroDefinitions = Record[2];
2504      unsigned LocalBaseMacroID = Record[3];
2505
2506      unsigned StartingID;
2507      if (PP) {
2508        if (!PP->getPreprocessingRecord())
2509          PP->createPreprocessingRecord(true);
2510        if (!PP->getPreprocessingRecord()->getExternalSource())
2511          PP->getPreprocessingRecord()->SetExternalSource(*this);
2512        StartingID
2513          = PP->getPreprocessingRecord()
2514              ->allocateLoadedEntities(F.NumPreallocatedPreprocessingEntities);
2515      } else {
2516        // FIXME: We'll eventually want to kill this path, since it assumes
2517        // a particular allocation strategy in the preprocessing record.
2518        StartingID = getTotalNumPreprocessedEntities()
2519                   - F.NumPreallocatedPreprocessingEntities;
2520      }
2521      F.BaseMacroDefinitionID = getTotalNumMacroDefinitions();
2522      F.BasePreprocessedEntityID = StartingID;
2523
2524      if (F.NumPreallocatedPreprocessingEntities > 0) {
2525        // Introduce the global -> local mapping for preprocessed entities in
2526        // this module.
2527        GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
2528
2529        // Introduce the local -> global mapping for preprocessed entities in
2530        // this module.
2531        F.PreprocessedEntityRemap.insert(
2532          std::make_pair(LocalBasePreprocessedEntityID,
2533            F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
2534      }
2535
2536
2537      if (F.LocalNumMacroDefinitions > 0) {
2538        // Introduce the global -> local mapping for macro definitions within
2539        // this module.
2540        GlobalMacroDefinitionMap.insert(
2541          std::make_pair(getTotalNumMacroDefinitions() + 1, &F));
2542
2543        // Introduce the local -> global mapping for macro definitions within
2544        // this module.
2545        F.MacroDefinitionRemap.insert(
2546          std::make_pair(LocalBaseMacroID,
2547                         F.BaseMacroDefinitionID - LocalBaseMacroID));
2548
2549        MacroDefinitionsLoaded.resize(
2550                    MacroDefinitionsLoaded.size() + F.LocalNumMacroDefinitions);
2551      }
2552
2553      break;
2554    }
2555
2556    case DECL_UPDATE_OFFSETS: {
2557      if (Record.size() % 2 != 0) {
2558        Error("invalid DECL_UPDATE_OFFSETS block in AST file");
2559        return Failure;
2560      }
2561      for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2562        DeclUpdateOffsets[getGlobalDeclID(F, Record[I])]
2563          .push_back(std::make_pair(&F, Record[I+1]));
2564      break;
2565    }
2566
2567    case DECL_REPLACEMENTS: {
2568      if (Record.size() % 2 != 0) {
2569        Error("invalid DECL_REPLACEMENTS block in AST file");
2570        return Failure;
2571      }
2572      for (unsigned I = 0, N = Record.size(); I != N; I += 2)
2573        ReplacedDecls[getGlobalDeclID(F, Record[I])]
2574          = std::make_pair(&F, Record[I+1]);
2575      break;
2576    }
2577
2578    case CXX_BASE_SPECIFIER_OFFSETS: {
2579      if (F.LocalNumCXXBaseSpecifiers != 0) {
2580        Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
2581        return Failure;
2582      }
2583
2584      F.LocalNumCXXBaseSpecifiers = Record[0];
2585      F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart;
2586      NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers;
2587      break;
2588    }
2589
2590    case DIAG_PRAGMA_MAPPINGS:
2591      if (Record.size() % 2 != 0) {
2592        Error("invalid DIAG_USER_MAPPINGS block in AST file");
2593        return Failure;
2594      }
2595
2596      if (F.PragmaDiagMappings.empty())
2597        F.PragmaDiagMappings.swap(Record);
2598      else
2599        F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
2600                                    Record.begin(), Record.end());
2601      break;
2602
2603    case CUDA_SPECIAL_DECL_REFS:
2604      // Later tables overwrite earlier ones.
2605      // FIXME: Modules will have trouble with this.
2606      CUDASpecialDeclRefs.clear();
2607      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2608        CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2609      break;
2610
2611    case HEADER_SEARCH_TABLE: {
2612      F.HeaderFileInfoTableData = BlobStart;
2613      F.LocalNumHeaderFileInfos = Record[1];
2614      F.HeaderFileFrameworkStrings = BlobStart + Record[2];
2615      if (Record[0]) {
2616        F.HeaderFileInfoTable
2617          = HeaderFileInfoLookupTable::Create(
2618                   (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
2619                   (const unsigned char *)F.HeaderFileInfoTableData,
2620                   HeaderFileInfoTrait(*this, F,
2621                                       PP? &PP->getHeaderSearchInfo() : 0,
2622                                       BlobStart + Record[2]));
2623        if (PP)
2624          PP->getHeaderSearchInfo().SetExternalSource(this);
2625      }
2626      break;
2627    }
2628
2629    case FP_PRAGMA_OPTIONS:
2630      // Later tables overwrite earlier ones.
2631      FPPragmaOptions.swap(Record);
2632      break;
2633
2634    case OPENCL_EXTENSIONS:
2635      // Later tables overwrite earlier ones.
2636      OpenCLExtensions.swap(Record);
2637      break;
2638
2639    case TENTATIVE_DEFINITIONS:
2640      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2641        TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2642      break;
2643
2644    case KNOWN_NAMESPACES:
2645      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2646        KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
2647      break;
2648    }
2649    First = false;
2650  }
2651  Error("premature end of bitstream in AST file");
2652  return Failure;
2653}
2654
2655ASTReader::ASTReadResult ASTReader::validateFileEntries() {
2656  for (ModuleIterator I = ModuleMgr.begin(),
2657      E = ModuleMgr.end(); I != E; ++I) {
2658    Module *F = *I;
2659    llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
2660
2661    for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) {
2662      SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]);
2663      unsigned Code = SLocEntryCursor.ReadCode();
2664      if (Code == llvm::bitc::END_BLOCK ||
2665          Code == llvm::bitc::ENTER_SUBBLOCK ||
2666          Code == llvm::bitc::DEFINE_ABBREV) {
2667        Error("incorrectly-formatted source location entry in AST file");
2668        return Failure;
2669      }
2670
2671      RecordData Record;
2672      const char *BlobStart;
2673      unsigned BlobLen;
2674      switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2675      default:
2676        Error("incorrectly-formatted source location entry in AST file");
2677        return Failure;
2678
2679      case SM_SLOC_FILE_ENTRY: {
2680        StringRef Filename(BlobStart, BlobLen);
2681        const FileEntry *File = getFileEntry(Filename);
2682
2683        if (File == 0) {
2684          std::string ErrorStr = "could not find file '";
2685          ErrorStr += Filename;
2686          ErrorStr += "' referenced by AST file";
2687          Error(ErrorStr.c_str());
2688          return IgnorePCH;
2689        }
2690
2691        if (Record.size() < 6) {
2692          Error("source location entry is incorrect");
2693          return Failure;
2694        }
2695
2696        // The stat info from the FileEntry came from the cached stat
2697        // info of the PCH, so we cannot trust it.
2698        struct stat StatBuf;
2699        if (::stat(File->getName(), &StatBuf) != 0) {
2700          StatBuf.st_size = File->getSize();
2701          StatBuf.st_mtime = File->getModificationTime();
2702        }
2703
2704        if (((off_t)Record[4] != StatBuf.st_size
2705#if !defined(LLVM_ON_WIN32)
2706            // In our regression testing, the Windows file system seems to
2707            // have inconsistent modification times that sometimes
2708            // erroneously trigger this error-handling path.
2709             || (time_t)Record[5] != StatBuf.st_mtime
2710#endif
2711            )) {
2712          Error(diag::err_fe_pch_file_modified, Filename);
2713          return IgnorePCH;
2714        }
2715
2716        break;
2717      }
2718      }
2719    }
2720  }
2721
2722  return Success;
2723}
2724
2725ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2726                                            ModuleKind Type) {
2727  switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) {
2728  case Failure: return Failure;
2729  case IgnorePCH: return IgnorePCH;
2730  case Success: break;
2731  }
2732
2733  // Here comes stuff that we only do once the entire chain is loaded.
2734
2735  if (!DisableValidation) {
2736    switch(validateFileEntries()) {
2737    case Failure: return Failure;
2738    case IgnorePCH: return IgnorePCH;
2739    case Success: break;
2740    }
2741  }
2742
2743  // Preload SLocEntries.
2744  for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
2745    ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
2746    if (Result != Success)
2747      return Failure;
2748  }
2749  PreloadSLocEntries.clear();
2750
2751  // Check the predefines buffers.
2752  if (!DisableValidation && Type != MK_Module && CheckPredefinesBuffers())
2753    return IgnorePCH;
2754
2755  if (PP) {
2756    // Initialization of keywords and pragmas occurs before the
2757    // AST file is read, so there may be some identifiers that were
2758    // loaded into the IdentifierTable before we intercepted the
2759    // creation of identifiers. Iterate through the list of known
2760    // identifiers and determine whether we have to establish
2761    // preprocessor definitions or top-level identifier declaration
2762    // chains for those identifiers.
2763    //
2764    // We copy the IdentifierInfo pointers to a small vector first,
2765    // since de-serializing declarations or macro definitions can add
2766    // new entries into the identifier table, invalidating the
2767    // iterators.
2768    //
2769    // FIXME: We need a lazier way to load this information, e.g., by marking
2770    // the identifier data as 'dirty', so that it will be looked up in the
2771    // AST file(s) if it is uttered in the source. This could save us some
2772    // module load time.
2773    SmallVector<IdentifierInfo *, 128> Identifiers;
2774    for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
2775                                IdEnd = PP->getIdentifierTable().end();
2776         Id != IdEnd; ++Id)
2777      Identifiers.push_back(Id->second);
2778    // We need to search the tables in all files.
2779    for (ModuleIterator J = ModuleMgr.begin(),
2780        M = ModuleMgr.end(); J != M; ++J) {
2781      ASTIdentifierLookupTable *IdTable
2782        = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable;
2783      // Not all AST files necessarily have identifier tables, only the useful
2784      // ones.
2785      if (!IdTable)
2786        continue;
2787      for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2788        IdentifierInfo *II = Identifiers[I];
2789        // Look in the on-disk hash tables for an entry for this identifier
2790        ASTIdentifierLookupTrait Info(*this, *(*J), II);
2791        std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
2792        ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
2793        if (Pos == IdTable->end())
2794          continue;
2795
2796        // Dereferencing the iterator has the effect of populating the
2797        // IdentifierInfo node with the various declarations it needs.
2798        (void)*Pos;
2799      }
2800    }
2801  }
2802
2803  if (Context)
2804    InitializeContext(*Context);
2805
2806  if (DeserializationListener)
2807    DeserializationListener->ReaderInitialized(this);
2808
2809  // If this AST file is a precompiled preamble, then set the main file ID of
2810  // the source manager to the file source file from which the preamble was
2811  // built. This is the only valid way to use a precompiled preamble.
2812  if (Type == MK_Preamble) {
2813    if (OriginalFileID.isInvalid()) {
2814      SourceLocation Loc
2815        = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2816      if (Loc.isValid())
2817        OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
2818    }
2819    else {
2820      OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
2821                                        + OriginalFileID.getOpaqueValue() - 1);
2822    }
2823
2824    if (!OriginalFileID.isInvalid())
2825      SourceMgr.SetPreambleFileID(OriginalFileID);
2826  }
2827
2828  return Success;
2829}
2830
2831ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
2832                                                ModuleKind Type,
2833                                                Module *ImportedBy) {
2834  Module &F = ModuleMgr.addModule(FileName, Type, ImportedBy);
2835
2836  if (FileName != "-") {
2837    CurrentDir = llvm::sys::path::parent_path(FileName);
2838    if (CurrentDir.empty()) CurrentDir = ".";
2839  }
2840
2841  if (llvm::MemoryBuffer *Buffer = ModuleMgr.lookupBuffer(FileName)) {
2842    F.Buffer.reset(Buffer);
2843    assert(F.Buffer && "Passed null buffer");
2844  } else {
2845    // Open the AST file.
2846    //
2847    // FIXME: This shouldn't be here, we should just take a raw_ostream.
2848    std::string ErrStr;
2849    llvm::error_code ec;
2850    if (FileName == "-") {
2851      ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2852      if (ec)
2853        ErrStr = ec.message();
2854    } else
2855      F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2856    if (!F.Buffer) {
2857      Error(ErrStr.c_str());
2858      return IgnorePCH;
2859    }
2860  }
2861
2862  // Initialize the stream
2863  F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2864                    (const unsigned char *)F.Buffer->getBufferEnd());
2865  llvm::BitstreamCursor &Stream = F.Stream;
2866  Stream.init(F.StreamFile);
2867  F.SizeInBits = F.Buffer->getBufferSize() * 8;
2868
2869  // Sniff for the signature.
2870  if (Stream.Read(8) != 'C' ||
2871      Stream.Read(8) != 'P' ||
2872      Stream.Read(8) != 'C' ||
2873      Stream.Read(8) != 'H') {
2874    Diag(diag::err_not_a_pch_file) << FileName;
2875    return Failure;
2876  }
2877
2878  while (!Stream.AtEndOfStream()) {
2879    unsigned Code = Stream.ReadCode();
2880
2881    if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2882      Error("invalid record at top-level of AST file");
2883      return Failure;
2884    }
2885
2886    unsigned BlockID = Stream.ReadSubBlockID();
2887
2888    // We only know the AST subblock ID.
2889    switch (BlockID) {
2890    case llvm::bitc::BLOCKINFO_BLOCK_ID:
2891      if (Stream.ReadBlockInfoBlock()) {
2892        Error("malformed BlockInfoBlock in AST file");
2893        return Failure;
2894      }
2895      break;
2896    case AST_BLOCK_ID:
2897      switch (ReadASTBlock(F)) {
2898      case Success:
2899        break;
2900
2901      case Failure:
2902        return Failure;
2903
2904      case IgnorePCH:
2905        // FIXME: We could consider reading through to the end of this
2906        // AST block, skipping subblocks, to see if there are other
2907        // AST blocks elsewhere.
2908
2909        // FIXME: We can't clear loaded slocentries anymore.
2910        //SourceMgr.ClearPreallocatedSLocEntries();
2911
2912        // Remove the stat cache.
2913        if (F.StatCache)
2914          FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2915
2916        return IgnorePCH;
2917      }
2918      break;
2919    default:
2920      if (Stream.SkipBlock()) {
2921        Error("malformed block record in AST file");
2922        return Failure;
2923      }
2924      break;
2925    }
2926  }
2927
2928  // Once read, set the Module bit base offset and update the size in
2929  // bits of all files we've seen.
2930  F.GlobalBitOffset = TotalModulesSizeInBits;
2931  TotalModulesSizeInBits += F.SizeInBits;
2932  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2933  return Success;
2934}
2935
2936void ASTReader::setPreprocessor(Preprocessor &pp) {
2937  PP = &pp;
2938
2939  if (unsigned N = getTotalNumPreprocessedEntities()) {
2940    if (!PP->getPreprocessingRecord())
2941      PP->createPreprocessingRecord(true);
2942    PP->getPreprocessingRecord()->SetExternalSource(*this);
2943    PP->getPreprocessingRecord()->allocateLoadedEntities(N);
2944  }
2945
2946  PP->getHeaderSearchInfo().SetExternalLookup(this);
2947  PP->getHeaderSearchInfo().SetExternalSource(this);
2948}
2949
2950void ASTReader::InitializeContext(ASTContext &Ctx) {
2951  Context = &Ctx;
2952  assert(Context && "Passed null context!");
2953
2954  assert(PP && "Forgot to set Preprocessor ?");
2955  PP->getIdentifierTable().setExternalIdentifierLookup(this);
2956  PP->setExternalSource(this);
2957
2958  // If we have an update block for the TU waiting, we have to add it before
2959  // deserializing the decl.
2960  TranslationUnitDecl *TU = Ctx.getTranslationUnitDecl();
2961  DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2962  if (DCU != DeclContextOffsets.end()) {
2963    // Insertion could invalidate map, so grab vector.
2964    DeclContextInfos T;
2965    T.swap(DCU->second);
2966    DeclContextOffsets.erase(DCU);
2967    DeclContextOffsets[TU].swap(T);
2968  }
2969
2970  // If there's a listener, notify them that we "read" the translation unit.
2971  if (DeserializationListener)
2972    DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, TU);
2973
2974  // Make sure we load the declaration update records for the translation unit,
2975  // if there are any.
2976  loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, TU);
2977
2978  // Note that the translation unit has external lexical and visible storage.
2979  TU->setHasExternalLexicalStorage(true);
2980  TU->setHasExternalVisibleStorage(true);
2981
2982  // FIXME: Find a better way to deal with collisions between these
2983  // built-in types. Right now, we just ignore the problem.
2984
2985  // Load the special types.
2986  if (Context->getBuiltinVaListType().isNull()) {
2987    Context->setBuiltinVaListType(
2988      GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2989  }
2990
2991  if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) {
2992    if (Context->ObjCProtoType.isNull())
2993      Context->ObjCProtoType = GetType(Proto);
2994  }
2995
2996  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
2997    if (!Context->CFConstantStringTypeDecl)
2998      Context->setCFConstantStringType(GetType(String));
2999  }
3000
3001  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3002    QualType FileType = GetType(File);
3003    if (FileType.isNull()) {
3004      Error("FILE type is NULL");
3005      return;
3006    }
3007
3008    if (!Context->FILEDecl) {
3009      if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3010        Context->setFILEDecl(Typedef->getDecl());
3011      else {
3012        const TagType *Tag = FileType->getAs<TagType>();
3013        if (!Tag) {
3014          Error("Invalid FILE type in AST file");
3015          return;
3016        }
3017        Context->setFILEDecl(Tag->getDecl());
3018      }
3019    }
3020  }
3021
3022  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
3023    QualType Jmp_bufType = GetType(Jmp_buf);
3024    if (Jmp_bufType.isNull()) {
3025      Error("jmp_buf type is NULL");
3026      return;
3027    }
3028
3029    if (!Context->jmp_bufDecl) {
3030      if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3031        Context->setjmp_bufDecl(Typedef->getDecl());
3032      else {
3033        const TagType *Tag = Jmp_bufType->getAs<TagType>();
3034        if (!Tag) {
3035          Error("Invalid jmp_buf type in AST file");
3036          return;
3037        }
3038        Context->setjmp_bufDecl(Tag->getDecl());
3039      }
3040    }
3041  }
3042
3043  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
3044    QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3045    if (Sigjmp_bufType.isNull()) {
3046      Error("sigjmp_buf type is NULL");
3047      return;
3048    }
3049
3050    if (!Context->sigjmp_bufDecl) {
3051      if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3052        Context->setsigjmp_bufDecl(Typedef->getDecl());
3053      else {
3054        const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
3055        assert(Tag && "Invalid sigjmp_buf type in AST file");
3056        Context->setsigjmp_bufDecl(Tag->getDecl());
3057      }
3058    }
3059  }
3060
3061  if (unsigned ObjCIdRedef
3062        = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
3063    if (Context->ObjCIdRedefinitionType.isNull())
3064      Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
3065  }
3066
3067  if (unsigned ObjCClassRedef
3068        = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
3069    if (Context->ObjCClassRedefinitionType.isNull())
3070      Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
3071  }
3072
3073  if (unsigned ObjCSelRedef
3074        = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
3075    if (Context->ObjCSelRedefinitionType.isNull())
3076      Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
3077  }
3078
3079  ReadPragmaDiagnosticMappings(Context->getDiagnostics());
3080
3081  // If there were any CUDA special declarations, deserialize them.
3082  if (!CUDASpecialDeclRefs.empty()) {
3083    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
3084    Context->setcudaConfigureCallDecl(
3085                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
3086  }
3087}
3088
3089/// \brief Retrieve the name of the original source file name
3090/// directly from the AST file, without actually loading the AST
3091/// file.
3092std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
3093                                             FileManager &FileMgr,
3094                                             Diagnostic &Diags) {
3095  // Open the AST file.
3096  std::string ErrStr;
3097  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
3098  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
3099  if (!Buffer) {
3100    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
3101    return std::string();
3102  }
3103
3104  // Initialize the stream
3105  llvm::BitstreamReader StreamFile;
3106  llvm::BitstreamCursor Stream;
3107  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
3108                  (const unsigned char *)Buffer->getBufferEnd());
3109  Stream.init(StreamFile);
3110
3111  // Sniff for the signature.
3112  if (Stream.Read(8) != 'C' ||
3113      Stream.Read(8) != 'P' ||
3114      Stream.Read(8) != 'C' ||
3115      Stream.Read(8) != 'H') {
3116    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
3117    return std::string();
3118  }
3119
3120  RecordData Record;
3121  while (!Stream.AtEndOfStream()) {
3122    unsigned Code = Stream.ReadCode();
3123
3124    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
3125      unsigned BlockID = Stream.ReadSubBlockID();
3126
3127      // We only know the AST subblock ID.
3128      switch (BlockID) {
3129      case AST_BLOCK_ID:
3130        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
3131          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3132          return std::string();
3133        }
3134        break;
3135
3136      default:
3137        if (Stream.SkipBlock()) {
3138          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
3139          return std::string();
3140        }
3141        break;
3142      }
3143      continue;
3144    }
3145
3146    if (Code == llvm::bitc::END_BLOCK) {
3147      if (Stream.ReadBlockEnd()) {
3148        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
3149        return std::string();
3150      }
3151      continue;
3152    }
3153
3154    if (Code == llvm::bitc::DEFINE_ABBREV) {
3155      Stream.ReadAbbrevRecord();
3156      continue;
3157    }
3158
3159    Record.clear();
3160    const char *BlobStart = 0;
3161    unsigned BlobLen = 0;
3162    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
3163          == ORIGINAL_FILE_NAME)
3164      return std::string(BlobStart, BlobLen);
3165  }
3166
3167  return std::string();
3168}
3169
3170/// \brief Parse the record that corresponds to a LangOptions data
3171/// structure.
3172///
3173/// This routine parses the language options from the AST file and then gives
3174/// them to the AST listener if one is set.
3175///
3176/// \returns true if the listener deems the file unacceptable, false otherwise.
3177bool ASTReader::ParseLanguageOptions(
3178                             const SmallVectorImpl<uint64_t> &Record) {
3179  if (Listener) {
3180    LangOptions LangOpts;
3181
3182  #define PARSE_LANGOPT(Option)                  \
3183      LangOpts.Option = Record[Idx];             \
3184      ++Idx
3185
3186    unsigned Idx = 0;
3187    PARSE_LANGOPT(Trigraphs);
3188    PARSE_LANGOPT(BCPLComment);
3189    PARSE_LANGOPT(DollarIdents);
3190    PARSE_LANGOPT(AsmPreprocessor);
3191    PARSE_LANGOPT(GNUMode);
3192    PARSE_LANGOPT(GNUKeywords);
3193    PARSE_LANGOPT(ImplicitInt);
3194    PARSE_LANGOPT(Digraphs);
3195    PARSE_LANGOPT(HexFloats);
3196    PARSE_LANGOPT(C99);
3197    PARSE_LANGOPT(C1X);
3198    PARSE_LANGOPT(Microsoft);
3199    PARSE_LANGOPT(CPlusPlus);
3200    PARSE_LANGOPT(CPlusPlus0x);
3201    PARSE_LANGOPT(CXXOperatorNames);
3202    PARSE_LANGOPT(ObjC1);
3203    PARSE_LANGOPT(ObjC2);
3204    PARSE_LANGOPT(ObjCNonFragileABI);
3205    PARSE_LANGOPT(ObjCNonFragileABI2);
3206    PARSE_LANGOPT(AppleKext);
3207    PARSE_LANGOPT(ObjCDefaultSynthProperties);
3208    PARSE_LANGOPT(ObjCInferRelatedResultType);
3209    PARSE_LANGOPT(NoConstantCFStrings);
3210    PARSE_LANGOPT(PascalStrings);
3211    PARSE_LANGOPT(WritableStrings);
3212    PARSE_LANGOPT(LaxVectorConversions);
3213    PARSE_LANGOPT(AltiVec);
3214    PARSE_LANGOPT(Exceptions);
3215    PARSE_LANGOPT(ObjCExceptions);
3216    PARSE_LANGOPT(CXXExceptions);
3217    PARSE_LANGOPT(SjLjExceptions);
3218    PARSE_LANGOPT(MSBitfields);
3219    PARSE_LANGOPT(NeXTRuntime);
3220    PARSE_LANGOPT(Freestanding);
3221    PARSE_LANGOPT(NoBuiltin);
3222    PARSE_LANGOPT(ThreadsafeStatics);
3223    PARSE_LANGOPT(POSIXThreads);
3224    PARSE_LANGOPT(Blocks);
3225    PARSE_LANGOPT(EmitAllDecls);
3226    PARSE_LANGOPT(MathErrno);
3227    LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
3228                                       Record[Idx++]);
3229    PARSE_LANGOPT(HeinousExtensions);
3230    PARSE_LANGOPT(Optimize);
3231    PARSE_LANGOPT(OptimizeSize);
3232    PARSE_LANGOPT(Static);
3233    PARSE_LANGOPT(PICLevel);
3234    PARSE_LANGOPT(GNUInline);
3235    PARSE_LANGOPT(NoInline);
3236    PARSE_LANGOPT(Deprecated);
3237    PARSE_LANGOPT(AccessControl);
3238    PARSE_LANGOPT(CharIsSigned);
3239    PARSE_LANGOPT(ShortWChar);
3240    PARSE_LANGOPT(ShortEnums);
3241    LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
3242    LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
3243    LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
3244                                   Record[Idx++]);
3245    PARSE_LANGOPT(InstantiationDepth);
3246    PARSE_LANGOPT(OpenCL);
3247    PARSE_LANGOPT(CUDA);
3248    PARSE_LANGOPT(CatchUndefined);
3249    PARSE_LANGOPT(DefaultFPContract);
3250    PARSE_LANGOPT(ElideConstructors);
3251    PARSE_LANGOPT(SpellChecking);
3252    PARSE_LANGOPT(MRTD);
3253    PARSE_LANGOPT(ObjCAutoRefCount);
3254    PARSE_LANGOPT(ObjCInferRelatedReturnType);
3255  #undef PARSE_LANGOPT
3256
3257    return Listener->ReadLanguageOptions(LangOpts);
3258  }
3259
3260  return false;
3261}
3262
3263void ASTReader::ReadPreprocessedEntities() {
3264  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3265    Module &F = *(*I);
3266    if (!F.PreprocessorDetailCursor.getBitStreamReader())
3267      continue;
3268
3269    SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
3270    F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
3271    while (LoadPreprocessedEntity(F)) { }
3272  }
3273}
3274
3275PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
3276  RecordLocation Loc = getLocalBitOffset(Offset);
3277
3278  // Keep track of where we are in the stream, then jump back there
3279  // after reading this entity.
3280  SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
3281  Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
3282  return LoadPreprocessedEntity(*Loc.F);
3283}
3284
3285HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3286  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3287    Module &F = *(*I);
3288
3289    HeaderFileInfoTrait Trait(*this, F, &PP->getHeaderSearchInfo(),
3290                              F.HeaderFileFrameworkStrings,
3291                              FE->getName());
3292
3293    HeaderFileInfoLookupTable *Table
3294      = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
3295    if (!Table)
3296      continue;
3297
3298    // Look in the on-disk hash table for an entry for this file name.
3299    HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
3300                                                          &Trait);
3301    if (Pos == Table->end())
3302      continue;
3303
3304    HeaderFileInfo HFI = *Pos;
3305    if (Listener)
3306      Listener->ReadHeaderFileInfo(HFI, FE->getUID());
3307
3308    return HFI;
3309  }
3310
3311  return HeaderFileInfo();
3312}
3313
3314void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3315  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3316    Module &F = *(*I);
3317    unsigned Idx = 0;
3318    while (Idx < F.PragmaDiagMappings.size()) {
3319      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3320      while (1) {
3321        assert(Idx < F.PragmaDiagMappings.size() &&
3322               "Invalid data, didn't find '-1' marking end of diag/map pairs");
3323        if (Idx >= F.PragmaDiagMappings.size()) {
3324          break; // Something is messed up but at least avoid infinite loop in
3325                 // release build.
3326        }
3327        unsigned DiagID = F.PragmaDiagMappings[Idx++];
3328        if (DiagID == (unsigned)-1) {
3329          break; // no more diag/map pairs for this location.
3330        }
3331        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3332        Diag.setDiagnosticMapping(DiagID, Map, Loc);
3333      }
3334    }
3335  }
3336}
3337
3338/// \brief Get the correct cursor and offset for loading a type.
3339ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3340  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
3341  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3342  Module *M = I->second;
3343  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
3344}
3345
3346/// \brief Read and return the type with the given index..
3347///
3348/// The index is the type ID, shifted and minus the number of predefs. This
3349/// routine actually reads the record corresponding to the type at the given
3350/// location. It is a helper routine for GetType, which deals with reading type
3351/// IDs.
3352QualType ASTReader::readTypeRecord(unsigned Index) {
3353  RecordLocation Loc = TypeCursorForIndex(Index);
3354  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3355
3356  // Keep track of where we are in the stream, then jump back there
3357  // after reading this type.
3358  SavedStreamPosition SavedPosition(DeclsCursor);
3359
3360  ReadingKindTracker ReadingKind(Read_Type, *this);
3361
3362  // Note that we are loading a type record.
3363  Deserializing AType(this);
3364
3365  unsigned Idx = 0;
3366  DeclsCursor.JumpToBit(Loc.Offset);
3367  RecordData Record;
3368  unsigned Code = DeclsCursor.ReadCode();
3369  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3370  case TYPE_EXT_QUAL: {
3371    if (Record.size() != 2) {
3372      Error("Incorrect encoding of extended qualifier type");
3373      return QualType();
3374    }
3375    QualType Base = readType(*Loc.F, Record, Idx);
3376    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3377    return Context->getQualifiedType(Base, Quals);
3378  }
3379
3380  case TYPE_COMPLEX: {
3381    if (Record.size() != 1) {
3382      Error("Incorrect encoding of complex type");
3383      return QualType();
3384    }
3385    QualType ElemType = readType(*Loc.F, Record, Idx);
3386    return Context->getComplexType(ElemType);
3387  }
3388
3389  case TYPE_POINTER: {
3390    if (Record.size() != 1) {
3391      Error("Incorrect encoding of pointer type");
3392      return QualType();
3393    }
3394    QualType PointeeType = readType(*Loc.F, Record, Idx);
3395    return Context->getPointerType(PointeeType);
3396  }
3397
3398  case TYPE_BLOCK_POINTER: {
3399    if (Record.size() != 1) {
3400      Error("Incorrect encoding of block pointer type");
3401      return QualType();
3402    }
3403    QualType PointeeType = readType(*Loc.F, Record, Idx);
3404    return Context->getBlockPointerType(PointeeType);
3405  }
3406
3407  case TYPE_LVALUE_REFERENCE: {
3408    if (Record.size() != 2) {
3409      Error("Incorrect encoding of lvalue reference type");
3410      return QualType();
3411    }
3412    QualType PointeeType = readType(*Loc.F, Record, Idx);
3413    return Context->getLValueReferenceType(PointeeType, Record[1]);
3414  }
3415
3416  case TYPE_RVALUE_REFERENCE: {
3417    if (Record.size() != 1) {
3418      Error("Incorrect encoding of rvalue reference type");
3419      return QualType();
3420    }
3421    QualType PointeeType = readType(*Loc.F, Record, Idx);
3422    return Context->getRValueReferenceType(PointeeType);
3423  }
3424
3425  case TYPE_MEMBER_POINTER: {
3426    if (Record.size() != 2) {
3427      Error("Incorrect encoding of member pointer type");
3428      return QualType();
3429    }
3430    QualType PointeeType = readType(*Loc.F, Record, Idx);
3431    QualType ClassType = readType(*Loc.F, Record, Idx);
3432    if (PointeeType.isNull() || ClassType.isNull())
3433      return QualType();
3434
3435    return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3436  }
3437
3438  case TYPE_CONSTANT_ARRAY: {
3439    QualType ElementType = readType(*Loc.F, Record, Idx);
3440    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3441    unsigned IndexTypeQuals = Record[2];
3442    unsigned Idx = 3;
3443    llvm::APInt Size = ReadAPInt(Record, Idx);
3444    return Context->getConstantArrayType(ElementType, Size,
3445                                         ASM, IndexTypeQuals);
3446  }
3447
3448  case TYPE_INCOMPLETE_ARRAY: {
3449    QualType ElementType = readType(*Loc.F, Record, Idx);
3450    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3451    unsigned IndexTypeQuals = Record[2];
3452    return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3453  }
3454
3455  case TYPE_VARIABLE_ARRAY: {
3456    QualType ElementType = readType(*Loc.F, Record, Idx);
3457    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3458    unsigned IndexTypeQuals = Record[2];
3459    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3460    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3461    return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3462                                         ASM, IndexTypeQuals,
3463                                         SourceRange(LBLoc, RBLoc));
3464  }
3465
3466  case TYPE_VECTOR: {
3467    if (Record.size() != 3) {
3468      Error("incorrect encoding of vector type in AST file");
3469      return QualType();
3470    }
3471
3472    QualType ElementType = readType(*Loc.F, Record, Idx);
3473    unsigned NumElements = Record[1];
3474    unsigned VecKind = Record[2];
3475    return Context->getVectorType(ElementType, NumElements,
3476                                  (VectorType::VectorKind)VecKind);
3477  }
3478
3479  case TYPE_EXT_VECTOR: {
3480    if (Record.size() != 3) {
3481      Error("incorrect encoding of extended vector type in AST file");
3482      return QualType();
3483    }
3484
3485    QualType ElementType = readType(*Loc.F, Record, Idx);
3486    unsigned NumElements = Record[1];
3487    return Context->getExtVectorType(ElementType, NumElements);
3488  }
3489
3490  case TYPE_FUNCTION_NO_PROTO: {
3491    if (Record.size() != 6) {
3492      Error("incorrect encoding of no-proto function type");
3493      return QualType();
3494    }
3495    QualType ResultType = readType(*Loc.F, Record, Idx);
3496    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3497                               (CallingConv)Record[4], Record[5]);
3498    return Context->getFunctionNoProtoType(ResultType, Info);
3499  }
3500
3501  case TYPE_FUNCTION_PROTO: {
3502    QualType ResultType = readType(*Loc.F, Record, Idx);
3503
3504    FunctionProtoType::ExtProtoInfo EPI;
3505    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3506                                        /*hasregparm*/ Record[2],
3507                                        /*regparm*/ Record[3],
3508                                        static_cast<CallingConv>(Record[4]),
3509                                        /*produces*/ Record[5]);
3510
3511    unsigned Idx = 6;
3512    unsigned NumParams = Record[Idx++];
3513    SmallVector<QualType, 16> ParamTypes;
3514    for (unsigned I = 0; I != NumParams; ++I)
3515      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3516
3517    EPI.Variadic = Record[Idx++];
3518    EPI.TypeQuals = Record[Idx++];
3519    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3520    ExceptionSpecificationType EST =
3521        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3522    EPI.ExceptionSpecType = EST;
3523    if (EST == EST_Dynamic) {
3524      EPI.NumExceptions = Record[Idx++];
3525      SmallVector<QualType, 2> Exceptions;
3526      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3527        Exceptions.push_back(readType(*Loc.F, Record, Idx));
3528      EPI.Exceptions = Exceptions.data();
3529    } else if (EST == EST_ComputedNoexcept) {
3530      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3531    }
3532    return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3533                                    EPI);
3534  }
3535
3536  case TYPE_UNRESOLVED_USING: {
3537    unsigned Idx = 0;
3538    return Context->getTypeDeclType(
3539                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3540  }
3541
3542  case TYPE_TYPEDEF: {
3543    if (Record.size() != 2) {
3544      Error("incorrect encoding of typedef type");
3545      return QualType();
3546    }
3547    unsigned Idx = 0;
3548    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3549    QualType Canonical = readType(*Loc.F, Record, Idx);
3550    if (!Canonical.isNull())
3551      Canonical = Context->getCanonicalType(Canonical);
3552    return Context->getTypedefType(Decl, Canonical);
3553  }
3554
3555  case TYPE_TYPEOF_EXPR:
3556    return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3557
3558  case TYPE_TYPEOF: {
3559    if (Record.size() != 1) {
3560      Error("incorrect encoding of typeof(type) in AST file");
3561      return QualType();
3562    }
3563    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3564    return Context->getTypeOfType(UnderlyingType);
3565  }
3566
3567  case TYPE_DECLTYPE:
3568    return Context->getDecltypeType(ReadExpr(*Loc.F));
3569
3570  case TYPE_UNARY_TRANSFORM: {
3571    QualType BaseType = readType(*Loc.F, Record, Idx);
3572    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3573    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3574    return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3575  }
3576
3577  case TYPE_AUTO:
3578    return Context->getAutoType(readType(*Loc.F, Record, Idx));
3579
3580  case TYPE_RECORD: {
3581    if (Record.size() != 2) {
3582      Error("incorrect encoding of record type");
3583      return QualType();
3584    }
3585    unsigned Idx = 0;
3586    bool IsDependent = Record[Idx++];
3587    QualType T
3588      = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
3589    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3590    return T;
3591  }
3592
3593  case TYPE_ENUM: {
3594    if (Record.size() != 2) {
3595      Error("incorrect encoding of enum type");
3596      return QualType();
3597    }
3598    unsigned Idx = 0;
3599    bool IsDependent = Record[Idx++];
3600    QualType T
3601      = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3602    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3603    return T;
3604  }
3605
3606  case TYPE_ATTRIBUTED: {
3607    if (Record.size() != 3) {
3608      Error("incorrect encoding of attributed type");
3609      return QualType();
3610    }
3611    QualType modifiedType = readType(*Loc.F, Record, Idx);
3612    QualType equivalentType = readType(*Loc.F, Record, Idx);
3613    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3614    return Context->getAttributedType(kind, modifiedType, equivalentType);
3615  }
3616
3617  case TYPE_PAREN: {
3618    if (Record.size() != 1) {
3619      Error("incorrect encoding of paren type");
3620      return QualType();
3621    }
3622    QualType InnerType = readType(*Loc.F, Record, Idx);
3623    return Context->getParenType(InnerType);
3624  }
3625
3626  case TYPE_PACK_EXPANSION: {
3627    if (Record.size() != 2) {
3628      Error("incorrect encoding of pack expansion type");
3629      return QualType();
3630    }
3631    QualType Pattern = readType(*Loc.F, Record, Idx);
3632    if (Pattern.isNull())
3633      return QualType();
3634    llvm::Optional<unsigned> NumExpansions;
3635    if (Record[1])
3636      NumExpansions = Record[1] - 1;
3637    return Context->getPackExpansionType(Pattern, NumExpansions);
3638  }
3639
3640  case TYPE_ELABORATED: {
3641    unsigned Idx = 0;
3642    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3643    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3644    QualType NamedType = readType(*Loc.F, Record, Idx);
3645    return Context->getElaboratedType(Keyword, NNS, NamedType);
3646  }
3647
3648  case TYPE_OBJC_INTERFACE: {
3649    unsigned Idx = 0;
3650    ObjCInterfaceDecl *ItfD
3651      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3652    return Context->getObjCInterfaceType(ItfD);
3653  }
3654
3655  case TYPE_OBJC_OBJECT: {
3656    unsigned Idx = 0;
3657    QualType Base = readType(*Loc.F, Record, Idx);
3658    unsigned NumProtos = Record[Idx++];
3659    SmallVector<ObjCProtocolDecl*, 4> Protos;
3660    for (unsigned I = 0; I != NumProtos; ++I)
3661      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
3662    return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3663  }
3664
3665  case TYPE_OBJC_OBJECT_POINTER: {
3666    unsigned Idx = 0;
3667    QualType Pointee = readType(*Loc.F, Record, Idx);
3668    return Context->getObjCObjectPointerType(Pointee);
3669  }
3670
3671  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3672    unsigned Idx = 0;
3673    QualType Parm = readType(*Loc.F, Record, Idx);
3674    QualType Replacement = readType(*Loc.F, Record, Idx);
3675    return
3676      Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3677                                            Replacement);
3678  }
3679
3680  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3681    unsigned Idx = 0;
3682    QualType Parm = readType(*Loc.F, Record, Idx);
3683    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3684    return Context->getSubstTemplateTypeParmPackType(
3685                                               cast<TemplateTypeParmType>(Parm),
3686                                                     ArgPack);
3687  }
3688
3689  case TYPE_INJECTED_CLASS_NAME: {
3690    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
3691    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
3692    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3693    // for AST reading, too much interdependencies.
3694    return
3695      QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3696  }
3697
3698  case TYPE_TEMPLATE_TYPE_PARM: {
3699    unsigned Idx = 0;
3700    unsigned Depth = Record[Idx++];
3701    unsigned Index = Record[Idx++];
3702    bool Pack = Record[Idx++];
3703    TemplateTypeParmDecl *D
3704      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
3705    return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
3706  }
3707
3708  case TYPE_DEPENDENT_NAME: {
3709    unsigned Idx = 0;
3710    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3711    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3712    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3713    QualType Canon = readType(*Loc.F, Record, Idx);
3714    if (!Canon.isNull())
3715      Canon = Context->getCanonicalType(Canon);
3716    return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3717  }
3718
3719  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3720    unsigned Idx = 0;
3721    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3722    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3723    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
3724    unsigned NumArgs = Record[Idx++];
3725    SmallVector<TemplateArgument, 8> Args;
3726    Args.reserve(NumArgs);
3727    while (NumArgs--)
3728      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3729    return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3730                                                      Args.size(), Args.data());
3731  }
3732
3733  case TYPE_DEPENDENT_SIZED_ARRAY: {
3734    unsigned Idx = 0;
3735
3736    // ArrayType
3737    QualType ElementType = readType(*Loc.F, Record, Idx);
3738    ArrayType::ArraySizeModifier ASM
3739      = (ArrayType::ArraySizeModifier)Record[Idx++];
3740    unsigned IndexTypeQuals = Record[Idx++];
3741
3742    // DependentSizedArrayType
3743    Expr *NumElts = ReadExpr(*Loc.F);
3744    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3745
3746    return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3747                                               IndexTypeQuals, Brackets);
3748  }
3749
3750  case TYPE_TEMPLATE_SPECIALIZATION: {
3751    unsigned Idx = 0;
3752    bool IsDependent = Record[Idx++];
3753    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3754    SmallVector<TemplateArgument, 8> Args;
3755    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3756    QualType Underlying = readType(*Loc.F, Record, Idx);
3757    QualType T;
3758    if (Underlying.isNull())
3759      T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3760                                                          Args.size());
3761    else
3762      T = Context->getTemplateSpecializationType(Name, Args.data(),
3763                                                 Args.size(), Underlying);
3764    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3765    return T;
3766  }
3767  }
3768  // Suppress a GCC warning
3769  return QualType();
3770}
3771
3772class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3773  ASTReader &Reader;
3774  Module &F;
3775  llvm::BitstreamCursor &DeclsCursor;
3776  const ASTReader::RecordData &Record;
3777  unsigned &Idx;
3778
3779  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3780                                    unsigned &I) {
3781    return Reader.ReadSourceLocation(F, R, I);
3782  }
3783
3784  template<typename T>
3785  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3786    return Reader.ReadDeclAs<T>(F, Record, Idx);
3787  }
3788
3789public:
3790  TypeLocReader(ASTReader &Reader, Module &F,
3791                const ASTReader::RecordData &Record, unsigned &Idx)
3792    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3793  { }
3794
3795  // We want compile-time assurance that we've enumerated all of
3796  // these, so unfortunately we have to declare them first, then
3797  // define them out-of-line.
3798#define ABSTRACT_TYPELOC(CLASS, PARENT)
3799#define TYPELOC(CLASS, PARENT) \
3800  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3801#include "clang/AST/TypeLocNodes.def"
3802
3803  void VisitFunctionTypeLoc(FunctionTypeLoc);
3804  void VisitArrayTypeLoc(ArrayTypeLoc);
3805};
3806
3807void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3808  // nothing to do
3809}
3810void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3811  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3812  if (TL.needsExtraLocalData()) {
3813    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3814    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3815    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3816    TL.setModeAttr(Record[Idx++]);
3817  }
3818}
3819void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3820  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3821}
3822void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3823  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3824}
3825void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3826  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3827}
3828void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3829  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3830}
3831void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3832  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3833}
3834void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3835  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3836  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3837}
3838void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3839  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3840  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3841  if (Record[Idx++])
3842    TL.setSizeExpr(Reader.ReadExpr(F));
3843  else
3844    TL.setSizeExpr(0);
3845}
3846void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3847  VisitArrayTypeLoc(TL);
3848}
3849void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3850  VisitArrayTypeLoc(TL);
3851}
3852void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3853  VisitArrayTypeLoc(TL);
3854}
3855void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3856                                            DependentSizedArrayTypeLoc TL) {
3857  VisitArrayTypeLoc(TL);
3858}
3859void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3860                                        DependentSizedExtVectorTypeLoc TL) {
3861  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3862}
3863void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3864  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3865}
3866void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3867  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3868}
3869void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3870  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3871  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3872  TL.setTrailingReturn(Record[Idx++]);
3873  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3874    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
3875  }
3876}
3877void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3878  VisitFunctionTypeLoc(TL);
3879}
3880void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3881  VisitFunctionTypeLoc(TL);
3882}
3883void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3884  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3885}
3886void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3887  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3888}
3889void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3890  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3891  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3892  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3893}
3894void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3895  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3896  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3897  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3898  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3899}
3900void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3901  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3902}
3903void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3904  TL.setKWLoc(ReadSourceLocation(Record, Idx));
3905  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3906  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3907  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3908}
3909void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3910  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3911}
3912void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3913  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3914}
3915void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3916  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3917}
3918void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3919  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3920  if (TL.hasAttrOperand()) {
3921    SourceRange range;
3922    range.setBegin(ReadSourceLocation(Record, Idx));
3923    range.setEnd(ReadSourceLocation(Record, Idx));
3924    TL.setAttrOperandParensRange(range);
3925  }
3926  if (TL.hasAttrExprOperand()) {
3927    if (Record[Idx++])
3928      TL.setAttrExprOperand(Reader.ReadExpr(F));
3929    else
3930      TL.setAttrExprOperand(0);
3931  } else if (TL.hasAttrEnumOperand())
3932    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3933}
3934void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3935  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3936}
3937void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3938                                            SubstTemplateTypeParmTypeLoc TL) {
3939  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3940}
3941void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3942                                          SubstTemplateTypeParmPackTypeLoc TL) {
3943  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3944}
3945void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3946                                           TemplateSpecializationTypeLoc TL) {
3947  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3948  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3949  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3950  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3951    TL.setArgLocInfo(i,
3952        Reader.GetTemplateArgumentLocInfo(F,
3953                                          TL.getTypePtr()->getArg(i).getKind(),
3954                                          Record, Idx));
3955}
3956void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3957  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3958  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3959}
3960void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3961  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3962  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3963}
3964void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3965  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3966}
3967void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3968  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3969  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3970  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3971}
3972void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3973       DependentTemplateSpecializationTypeLoc TL) {
3974  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3975  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3976  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3977  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3978  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3979  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3980    TL.setArgLocInfo(I,
3981        Reader.GetTemplateArgumentLocInfo(F,
3982                                          TL.getTypePtr()->getArg(I).getKind(),
3983                                          Record, Idx));
3984}
3985void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3986  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3987}
3988void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3989  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3990}
3991void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3992  TL.setHasBaseTypeAsWritten(Record[Idx++]);
3993  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3994  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3995  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3996    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3997}
3998void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3999  TL.setStarLoc(ReadSourceLocation(Record, Idx));
4000}
4001
4002TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
4003                                             const RecordData &Record,
4004                                             unsigned &Idx) {
4005  QualType InfoTy = readType(F, Record, Idx);
4006  if (InfoTy.isNull())
4007    return 0;
4008
4009  TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
4010  TypeLocReader TLR(*this, F, Record, Idx);
4011  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
4012    TLR.Visit(TL);
4013  return TInfo;
4014}
4015
4016QualType ASTReader::GetType(TypeID ID) {
4017  unsigned FastQuals = ID & Qualifiers::FastMask;
4018  unsigned Index = ID >> Qualifiers::FastWidth;
4019
4020  if (Index < NUM_PREDEF_TYPE_IDS) {
4021    QualType T;
4022    switch ((PredefinedTypeIDs)Index) {
4023    case PREDEF_TYPE_NULL_ID: return QualType();
4024    case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
4025    case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
4026
4027    case PREDEF_TYPE_CHAR_U_ID:
4028    case PREDEF_TYPE_CHAR_S_ID:
4029      // FIXME: Check that the signedness of CharTy is correct!
4030      T = Context->CharTy;
4031      break;
4032
4033    case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
4034    case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
4035    case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
4036    case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
4037    case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
4038    case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
4039    case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
4040    case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
4041    case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
4042    case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
4043    case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
4044    case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
4045    case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
4046    case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
4047    case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
4048    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
4049    case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
4050    case PREDEF_TYPE_BOUND_MEMBER:  T = Context->BoundMemberTy;      break;
4051    case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
4052    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
4053    case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
4054    case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
4055    case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
4056    case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
4057    case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
4058    case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
4059    case PREDEF_TYPE_AUTO_DEDUCT:   T = Context->getAutoDeductType(); break;
4060
4061    case PREDEF_TYPE_AUTO_RREF_DEDUCT:
4062      T = Context->getAutoRRefDeductType();
4063      break;
4064    }
4065
4066    assert(!T.isNull() && "Unknown predefined type");
4067    return T.withFastQualifiers(FastQuals);
4068  }
4069
4070  Index -= NUM_PREDEF_TYPE_IDS;
4071  assert(Index < TypesLoaded.size() && "Type index out-of-range");
4072  if (TypesLoaded[Index].isNull()) {
4073    TypesLoaded[Index] = readTypeRecord(Index);
4074    if (TypesLoaded[Index].isNull())
4075      return QualType();
4076
4077    TypesLoaded[Index]->setFromAST();
4078    if (DeserializationListener)
4079      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
4080                                        TypesLoaded[Index]);
4081  }
4082
4083  return TypesLoaded[Index].withFastQualifiers(FastQuals);
4084}
4085
4086QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
4087  return GetType(getGlobalTypeID(F, LocalID));
4088}
4089
4090serialization::TypeID
4091ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
4092  unsigned FastQuals = LocalID & Qualifiers::FastMask;
4093  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
4094
4095  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
4096    return LocalID;
4097
4098  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4099    = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
4100  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
4101
4102  unsigned GlobalIndex = LocalIndex + I->second;
4103  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
4104}
4105
4106TemplateArgumentLocInfo
4107ASTReader::GetTemplateArgumentLocInfo(Module &F,
4108                                      TemplateArgument::ArgKind Kind,
4109                                      const RecordData &Record,
4110                                      unsigned &Index) {
4111  switch (Kind) {
4112  case TemplateArgument::Expression:
4113    return ReadExpr(F);
4114  case TemplateArgument::Type:
4115    return GetTypeSourceInfo(F, Record, Index);
4116  case TemplateArgument::Template: {
4117    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4118                                                                     Index);
4119    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4120    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4121                                   SourceLocation());
4122  }
4123  case TemplateArgument::TemplateExpansion: {
4124    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
4125                                                                     Index);
4126    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
4127    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
4128    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
4129                                   EllipsisLoc);
4130  }
4131  case TemplateArgument::Null:
4132  case TemplateArgument::Integral:
4133  case TemplateArgument::Declaration:
4134  case TemplateArgument::Pack:
4135    return TemplateArgumentLocInfo();
4136  }
4137  llvm_unreachable("unexpected template argument loc");
4138  return TemplateArgumentLocInfo();
4139}
4140
4141TemplateArgumentLoc
4142ASTReader::ReadTemplateArgumentLoc(Module &F,
4143                                   const RecordData &Record, unsigned &Index) {
4144  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
4145
4146  if (Arg.getKind() == TemplateArgument::Expression) {
4147    if (Record[Index++]) // bool InfoHasSameExpr.
4148      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
4149  }
4150  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
4151                                                             Record, Index));
4152}
4153
4154Decl *ASTReader::GetExternalDecl(uint32_t ID) {
4155  return GetDecl(ID);
4156}
4157
4158uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record,
4159                                          unsigned &Idx){
4160  if (Idx >= Record.size())
4161    return 0;
4162
4163  unsigned LocalID = Record[Idx++];
4164  return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
4165}
4166
4167CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
4168  RecordLocation Loc = getLocalBitOffset(Offset);
4169  llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
4170  SavedStreamPosition SavedPosition(Cursor);
4171  Cursor.JumpToBit(Loc.Offset);
4172  ReadingKindTracker ReadingKind(Read_Decl, *this);
4173  RecordData Record;
4174  unsigned Code = Cursor.ReadCode();
4175  unsigned RecCode = Cursor.ReadRecord(Code, Record);
4176  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
4177    Error("Malformed AST file: missing C++ base specifiers");
4178    return 0;
4179  }
4180
4181  unsigned Idx = 0;
4182  unsigned NumBases = Record[Idx++];
4183  void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
4184  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
4185  for (unsigned I = 0; I != NumBases; ++I)
4186    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
4187  return Bases;
4188}
4189
4190serialization::DeclID
4191ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
4192  if (LocalID < NUM_PREDEF_DECL_IDS)
4193    return LocalID;
4194
4195  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4196    = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
4197  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
4198
4199  return LocalID + I->second;
4200}
4201
4202Decl *ASTReader::GetDecl(DeclID ID) {
4203  if (ID < NUM_PREDEF_DECL_IDS) {
4204    switch ((PredefinedDeclIDs)ID) {
4205    case PREDEF_DECL_NULL_ID:
4206      return 0;
4207
4208    case PREDEF_DECL_TRANSLATION_UNIT_ID:
4209      assert(Context && "No context available?");
4210      return Context->getTranslationUnitDecl();
4211
4212    case PREDEF_DECL_OBJC_ID_ID:
4213      assert(Context && "No context available?");
4214      return Context->getObjCIdDecl();
4215
4216    case PREDEF_DECL_OBJC_SEL_ID:
4217      assert(Context && "No context available?");
4218      return Context->getObjCSelDecl();
4219
4220    case PREDEF_DECL_OBJC_CLASS_ID:
4221      assert(Context && "No context available?");
4222      return Context->getObjCClassDecl();
4223
4224    case PREDEF_DECL_INT_128_ID:
4225      assert(Context && "No context available?");
4226      return Context->getInt128Decl();
4227
4228    case PREDEF_DECL_UNSIGNED_INT_128_ID:
4229      assert(Context && "No context available?");
4230      return Context->getUInt128Decl();
4231    }
4232
4233    return 0;
4234  }
4235
4236  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
4237
4238  if (Index > DeclsLoaded.size()) {
4239    Error("declaration ID out-of-range for AST file");
4240    return 0;
4241  }
4242
4243if (!DeclsLoaded[Index]) {
4244    ReadDeclRecord(ID);
4245    if (DeserializationListener)
4246      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4247  }
4248
4249  return DeclsLoaded[Index];
4250}
4251
4252serialization::DeclID ASTReader::ReadDeclID(Module &F,
4253                                            const RecordData &Record,
4254                                            unsigned &Idx) {
4255  if (Idx >= Record.size()) {
4256    Error("Corrupted AST file");
4257    return 0;
4258  }
4259
4260  return getGlobalDeclID(F, Record[Idx++]);
4261}
4262
4263/// \brief Resolve the offset of a statement into a statement.
4264///
4265/// This operation will read a new statement from the external
4266/// source each time it is called, and is meant to be used via a
4267/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
4268Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
4269  // Switch case IDs are per Decl.
4270  ClearSwitchCaseIDs();
4271
4272  // Offset here is a global offset across the entire chain.
4273  RecordLocation Loc = getLocalBitOffset(Offset);
4274  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4275  return ReadStmtFromStream(*Loc.F);
4276}
4277
4278ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4279                                         bool (*isKindWeWant)(Decl::Kind),
4280                                         SmallVectorImpl<Decl*> &Decls) {
4281  // There might be lexical decls in multiple parts of the chain, for the TU
4282  // at least.
4283  // DeclContextOffsets might reallocate as we load additional decls below,
4284  // so make a copy of the vector.
4285  DeclContextInfos Infos = DeclContextOffsets[DC];
4286  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4287       I != E; ++I) {
4288    // IDs can be 0 if this context doesn't contain declarations.
4289    if (!I->LexicalDecls)
4290      continue;
4291
4292    // Load all of the declaration IDs
4293    for (const KindDeclIDPair *ID = I->LexicalDecls,
4294                              *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
4295      if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
4296        continue;
4297
4298      Decl *D = GetLocalDecl(*I->F, ID->second);
4299      assert(D && "Null decl in lexical decls");
4300      Decls.push_back(D);
4301    }
4302  }
4303
4304  ++NumLexicalDeclContextsRead;
4305  return ELR_Success;
4306}
4307
4308DeclContext::lookup_result
4309ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4310                                          DeclarationName Name) {
4311  assert(DC->hasExternalVisibleStorage() &&
4312         "DeclContext has no visible decls in storage");
4313  if (!Name)
4314    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4315                                      DeclContext::lookup_iterator(0));
4316
4317  SmallVector<NamedDecl *, 64> Decls;
4318  // There might be visible decls in multiple parts of the chain, for the TU
4319  // and namespaces. For any given name, the last available results replace
4320  // all earlier ones. For this reason, we walk in reverse.
4321  // Copy the DeclContextInfos vector instead of using a reference to the
4322  // vector stored in the map, because DeclContextOffsets can change while
4323  // we load declarations with GetLocalDeclAs.
4324  DeclContextInfos Infos = DeclContextOffsets[DC];
4325  for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
4326       I != E; ++I) {
4327    if (!I->NameLookupTableData)
4328      continue;
4329
4330    ASTDeclContextNameLookupTable *LookupTable =
4331        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4332    ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
4333    if (Pos == LookupTable->end())
4334      continue;
4335
4336    ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4337    for (; Data.first != Data.second; ++Data.first) {
4338      NamedDecl *ND = GetLocalDeclAs<NamedDecl>(*I->F, *Data.first);
4339      if (!ND)
4340        continue;
4341
4342      if (ND->getDeclName() != Name) {
4343        assert(!Name.getCXXNameType().isNull() &&
4344               "Name mismatch without a type");
4345        continue;
4346      }
4347
4348      Decls.push_back(ND);
4349    }
4350
4351    // If we rejected all of the declarations we found, e.g., because the
4352    // name didn't actually match, continue looking through DeclContexts.
4353    if (Decls.empty())
4354      continue;
4355
4356    break;
4357  }
4358
4359  ++NumVisibleDeclContextsRead;
4360
4361  SetExternalVisibleDeclsForName(DC, Name, Decls);
4362  return const_cast<DeclContext*>(DC)->lookup(Name);
4363}
4364
4365void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
4366  assert(DC->hasExternalVisibleStorage() &&
4367         "DeclContext has no visible decls in storage");
4368
4369  SmallVector<NamedDecl *, 64> Decls;
4370  // There might be visible decls in multiple parts of the chain, for the TU
4371  // and namespaces.
4372  DeclContextInfos &Infos = DeclContextOffsets[DC];
4373  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4374       I != E; ++I) {
4375    if (!I->NameLookupTableData)
4376      continue;
4377
4378    ASTDeclContextNameLookupTable *LookupTable =
4379        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4380    for (ASTDeclContextNameLookupTable::item_iterator
4381           ItemI = LookupTable->item_begin(),
4382           ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
4383      ASTDeclContextNameLookupTable::item_iterator::value_type Val
4384          = *ItemI;
4385      ASTDeclContextNameLookupTrait::data_type Data = Val.second;
4386      Decls.clear();
4387      for (; Data.first != Data.second; ++Data.first)
4388        Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
4389      MaterializeVisibleDeclsForName(DC, Val.first, Decls);
4390    }
4391  }
4392}
4393
4394void ASTReader::PassInterestingDeclsToConsumer() {
4395  assert(Consumer);
4396  while (!InterestingDecls.empty()) {
4397    DeclGroupRef DG(InterestingDecls.front());
4398    InterestingDecls.pop_front();
4399    Consumer->HandleInterestingDecl(DG);
4400  }
4401}
4402
4403void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4404  this->Consumer = Consumer;
4405
4406  if (!Consumer)
4407    return;
4408
4409  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4410    // Force deserialization of this decl, which will cause it to be queued for
4411    // passing to the consumer.
4412    GetDecl(ExternalDefinitions[I]);
4413  }
4414
4415  PassInterestingDeclsToConsumer();
4416}
4417
4418void ASTReader::PrintStats() {
4419  std::fprintf(stderr, "*** AST File Statistics:\n");
4420
4421  unsigned NumTypesLoaded
4422    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4423                                      QualType());
4424  unsigned NumDeclsLoaded
4425    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4426                                      (Decl *)0);
4427  unsigned NumIdentifiersLoaded
4428    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4429                                            IdentifiersLoaded.end(),
4430                                            (IdentifierInfo *)0);
4431  unsigned NumSelectorsLoaded
4432    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4433                                          SelectorsLoaded.end(),
4434                                          Selector());
4435
4436  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4437  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4438  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
4439    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4440                 NumSLocEntriesRead, TotalNumSLocEntries,
4441                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4442  if (!TypesLoaded.empty())
4443    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4444                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4445                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4446  if (!DeclsLoaded.empty())
4447    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4448                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4449                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4450  if (!IdentifiersLoaded.empty())
4451    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4452                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4453                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4454  if (!SelectorsLoaded.empty())
4455    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4456                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4457                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4458  if (TotalNumStatements)
4459    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4460                 NumStatementsRead, TotalNumStatements,
4461                 ((float)NumStatementsRead/TotalNumStatements * 100));
4462  if (TotalNumMacros)
4463    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4464                 NumMacrosRead, TotalNumMacros,
4465                 ((float)NumMacrosRead/TotalNumMacros * 100));
4466  if (TotalLexicalDeclContexts)
4467    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4468                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4469                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4470                  * 100));
4471  if (TotalVisibleDeclContexts)
4472    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4473                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4474                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4475                  * 100));
4476  if (TotalNumMethodPoolEntries) {
4477    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4478                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4479                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4480                  * 100));
4481    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4482  }
4483  std::fprintf(stderr, "\n");
4484  dump();
4485  std::fprintf(stderr, "\n");
4486}
4487
4488template<typename Key, typename Module, unsigned InitialCapacity>
4489static void
4490dumpModuleIDMap(StringRef Name,
4491                const ContinuousRangeMap<Key, Module *,
4492                                         InitialCapacity> &Map) {
4493  if (Map.begin() == Map.end())
4494    return;
4495
4496  typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
4497  llvm::errs() << Name << ":\n";
4498  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4499       I != IEnd; ++I) {
4500    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
4501      << "\n";
4502  }
4503}
4504
4505void ASTReader::dump() {
4506  llvm::errs() << "*** PCH/Module Remappings:\n";
4507  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
4508  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
4509  dumpModuleIDMap("Global type map", GlobalTypeMap);
4510  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
4511  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
4512  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
4513  dumpModuleIDMap("Global macro definition map", GlobalMacroDefinitionMap);
4514  dumpModuleIDMap("Global preprocessed entity map",
4515                  GlobalPreprocessedEntityMap);
4516
4517  llvm::errs() << "\n*** PCH/Modules Loaded:";
4518  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
4519                                       MEnd = ModuleMgr.end();
4520       M != MEnd; ++M)
4521    (*M)->dump();
4522}
4523
4524/// Return the amount of memory used by memory buffers, breaking down
4525/// by heap-backed versus mmap'ed memory.
4526void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4527  for (ModuleConstIterator I = ModuleMgr.begin(),
4528      E = ModuleMgr.end(); I != E; ++I) {
4529    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4530      size_t bytes = buf->getBufferSize();
4531      switch (buf->getBufferKind()) {
4532        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4533          sizes.malloc_bytes += bytes;
4534          break;
4535        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4536          sizes.mmap_bytes += bytes;
4537          break;
4538      }
4539    }
4540  }
4541}
4542
4543void ASTReader::InitializeSema(Sema &S) {
4544  SemaObj = &S;
4545  S.ExternalSource = this;
4546
4547  // Makes sure any declarations that were deserialized "too early"
4548  // still get added to the identifier's declaration chains.
4549  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4550    if (SemaObj->TUScope)
4551      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4552
4553    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4554  }
4555  PreloadedDecls.clear();
4556
4557  // Load the offsets of the declarations that Sema references.
4558  // They will be lazily deserialized when needed.
4559  if (!SemaDeclRefs.empty()) {
4560    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4561    if (!SemaObj->StdNamespace)
4562      SemaObj->StdNamespace = SemaDeclRefs[0];
4563    if (!SemaObj->StdBadAlloc)
4564      SemaObj->StdBadAlloc = SemaDeclRefs[1];
4565  }
4566
4567  if (!FPPragmaOptions.empty()) {
4568    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4569    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4570  }
4571
4572  if (!OpenCLExtensions.empty()) {
4573    unsigned I = 0;
4574#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4575#include "clang/Basic/OpenCLExtensions.def"
4576
4577    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4578  }
4579}
4580
4581IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4582  // Try to find this name within our on-disk hash tables. We start with the
4583  // most recent one, since that one contains the most up-to-date info.
4584  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4585    ASTIdentifierLookupTable *IdTable
4586        = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
4587    if (!IdTable)
4588      continue;
4589    std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4590    ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4591    if (Pos == IdTable->end())
4592      continue;
4593
4594    // Dereferencing the iterator has the effect of building the
4595    // IdentifierInfo node and populating it with the various
4596    // declarations it needs.
4597    return *Pos;
4598  }
4599  return 0;
4600}
4601
4602namespace clang {
4603  /// \brief An identifier-lookup iterator that enumerates all of the
4604  /// identifiers stored within a set of AST files.
4605  class ASTIdentifierIterator : public IdentifierIterator {
4606    /// \brief The AST reader whose identifiers are being enumerated.
4607    const ASTReader &Reader;
4608
4609    /// \brief The current index into the chain of AST files stored in
4610    /// the AST reader.
4611    unsigned Index;
4612
4613    /// \brief The current position within the identifier lookup table
4614    /// of the current AST file.
4615    ASTIdentifierLookupTable::key_iterator Current;
4616
4617    /// \brief The end position within the identifier lookup table of
4618    /// the current AST file.
4619    ASTIdentifierLookupTable::key_iterator End;
4620
4621  public:
4622    explicit ASTIdentifierIterator(const ASTReader &Reader);
4623
4624    virtual StringRef Next();
4625  };
4626}
4627
4628ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4629  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4630  ASTIdentifierLookupTable *IdTable
4631    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4632  Current = IdTable->key_begin();
4633  End = IdTable->key_end();
4634}
4635
4636StringRef ASTIdentifierIterator::Next() {
4637  while (Current == End) {
4638    // If we have exhausted all of our AST files, we're done.
4639    if (Index == 0)
4640      return StringRef();
4641
4642    --Index;
4643    ASTIdentifierLookupTable *IdTable
4644      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4645        IdentifierLookupTable;
4646    Current = IdTable->key_begin();
4647    End = IdTable->key_end();
4648  }
4649
4650  // We have any identifiers remaining in the current AST file; return
4651  // the next one.
4652  std::pair<const char*, unsigned> Key = *Current;
4653  ++Current;
4654  return StringRef(Key.first, Key.second);
4655}
4656
4657IdentifierIterator *ASTReader::getIdentifiers() const {
4658  return new ASTIdentifierIterator(*this);
4659}
4660
4661std::pair<ObjCMethodList, ObjCMethodList>
4662ASTReader::ReadMethodPool(Selector Sel) {
4663  // Find this selector in a hash table. We want to find the most recent entry.
4664  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4665    Module &F = *(*I);
4666    if (!F.SelectorLookupTable)
4667      continue;
4668
4669    ASTSelectorLookupTable *PoolTable
4670      = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4671    ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4672    if (Pos != PoolTable->end()) {
4673      ++NumSelectorsRead;
4674      // FIXME: Not quite happy with the statistics here. We probably should
4675      // disable this tracking when called via LoadSelector.
4676      // Also, should entries without methods count as misses?
4677      ++NumMethodPoolEntriesRead;
4678      ASTSelectorLookupTrait::data_type Data = *Pos;
4679      if (DeserializationListener)
4680        DeserializationListener->SelectorRead(Data.ID, Sel);
4681      return std::make_pair(Data.Instance, Data.Factory);
4682    }
4683  }
4684
4685  ++NumMethodPoolMisses;
4686  return std::pair<ObjCMethodList, ObjCMethodList>();
4687}
4688
4689void ASTReader::ReadKnownNamespaces(
4690                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4691  Namespaces.clear();
4692
4693  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4694    if (NamespaceDecl *Namespace
4695                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4696      Namespaces.push_back(Namespace);
4697  }
4698}
4699
4700void ASTReader::ReadTentativeDefinitions(
4701                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
4702  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4703    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
4704    if (Var)
4705      TentativeDefs.push_back(Var);
4706  }
4707  TentativeDefinitions.clear();
4708}
4709
4710void ASTReader::ReadUnusedFileScopedDecls(
4711                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
4712  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4713    DeclaratorDecl *D
4714      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4715    if (D)
4716      Decls.push_back(D);
4717  }
4718  UnusedFileScopedDecls.clear();
4719}
4720
4721void ASTReader::ReadDelegatingConstructors(
4722                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
4723  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4724    CXXConstructorDecl *D
4725      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4726    if (D)
4727      Decls.push_back(D);
4728  }
4729  DelegatingCtorDecls.clear();
4730}
4731
4732void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
4733  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
4734    TypedefNameDecl *D
4735      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
4736    if (D)
4737      Decls.push_back(D);
4738  }
4739  ExtVectorDecls.clear();
4740}
4741
4742void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
4743  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
4744    CXXRecordDecl *D
4745      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
4746    if (D)
4747      Decls.push_back(D);
4748  }
4749  DynamicClasses.clear();
4750}
4751
4752void
4753ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) {
4754  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4755    NamedDecl *D
4756      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4757    if (D)
4758      Decls.push_back(D);
4759  }
4760  LocallyScopedExternalDecls.clear();
4761}
4762
4763void ASTReader::ReadReferencedSelectors(
4764       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
4765  if (ReferencedSelectorsData.empty())
4766    return;
4767
4768  // If there are @selector references added them to its pool. This is for
4769  // implementation of -Wselector.
4770  unsigned int DataSize = ReferencedSelectorsData.size()-1;
4771  unsigned I = 0;
4772  while (I < DataSize) {
4773    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
4774    SourceLocation SelLoc
4775      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
4776    Sels.push_back(std::make_pair(Sel, SelLoc));
4777  }
4778  ReferencedSelectorsData.clear();
4779}
4780
4781void ASTReader::ReadWeakUndeclaredIdentifiers(
4782       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
4783  if (WeakUndeclaredIdentifiers.empty())
4784    return;
4785
4786  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
4787    IdentifierInfo *WeakId
4788      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4789    IdentifierInfo *AliasId
4790      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
4791    SourceLocation Loc
4792      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
4793    bool Used = WeakUndeclaredIdentifiers[I++];
4794    WeakInfo WI(AliasId, Loc);
4795    WI.setUsed(Used);
4796    WeakIDs.push_back(std::make_pair(WeakId, WI));
4797  }
4798  WeakUndeclaredIdentifiers.clear();
4799}
4800
4801void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
4802  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
4803    ExternalVTableUse VT;
4804    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4805    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
4806    VT.DefinitionRequired = VTableUses[Idx++];
4807    VTables.push_back(VT);
4808  }
4809
4810  VTableUses.clear();
4811}
4812
4813void ASTReader::ReadPendingInstantiations(
4814       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
4815  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
4816    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
4817    SourceLocation Loc
4818      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
4819    Pending.push_back(std::make_pair(D, Loc));
4820  }
4821  PendingInstantiations.clear();
4822}
4823
4824void ASTReader::LoadSelector(Selector Sel) {
4825  // It would be complicated to avoid reading the methods anyway. So don't.
4826  ReadMethodPool(Sel);
4827}
4828
4829void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
4830  assert(ID && "Non-zero identifier ID required");
4831  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4832  IdentifiersLoaded[ID - 1] = II;
4833  if (DeserializationListener)
4834    DeserializationListener->IdentifierRead(ID, II);
4835}
4836
4837/// \brief Set the globally-visible declarations associated with the given
4838/// identifier.
4839///
4840/// If the AST reader is currently in a state where the given declaration IDs
4841/// cannot safely be resolved, they are queued until it is safe to resolve
4842/// them.
4843///
4844/// \param II an IdentifierInfo that refers to one or more globally-visible
4845/// declarations.
4846///
4847/// \param DeclIDs the set of declaration IDs with the name @p II that are
4848/// visible at global scope.
4849///
4850/// \param Nonrecursive should be true to indicate that the caller knows that
4851/// this call is non-recursive, and therefore the globally-visible declarations
4852/// will not be placed onto the pending queue.
4853void
4854ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4855                              const SmallVectorImpl<uint32_t> &DeclIDs,
4856                                   bool Nonrecursive) {
4857  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4858    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4859    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4860    PII.II = II;
4861    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4862    return;
4863  }
4864
4865  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4866    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4867    if (SemaObj) {
4868      if (SemaObj->TUScope) {
4869        // Introduce this declaration into the translation-unit scope
4870        // and add it to the declaration chain for this identifier, so
4871        // that (unqualified) name lookup will find it.
4872        SemaObj->TUScope->AddDecl(D);
4873      }
4874      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4875    } else {
4876      // Queue this declaration so that it will be added to the
4877      // translation unit scope and identifier's declaration chain
4878      // once a Sema object is known.
4879      PreloadedDecls.push_back(D);
4880    }
4881  }
4882}
4883
4884IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
4885  if (ID == 0)
4886    return 0;
4887
4888  if (IdentifiersLoaded.empty()) {
4889    Error("no identifier table in AST file");
4890    return 0;
4891  }
4892
4893  assert(PP && "Forgot to set Preprocessor ?");
4894  ID -= 1;
4895  if (!IdentifiersLoaded[ID]) {
4896    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4897    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4898    Module *M = I->second;
4899    unsigned Index = ID - M->BaseIdentifierID;
4900    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
4901
4902    // All of the strings in the AST file are preceded by a 16-bit length.
4903    // Extract that 16-bit length to avoid having to execute strlen().
4904    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4905    //  unsigned integers.  This is important to avoid integer overflow when
4906    //  we cast them to 'unsigned'.
4907    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4908    unsigned StrLen = (((unsigned) StrLenPtr[0])
4909                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4910    IdentifiersLoaded[ID]
4911      = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
4912    if (DeserializationListener)
4913      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4914  }
4915
4916  return IdentifiersLoaded[ID];
4917}
4918
4919IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) {
4920  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
4921}
4922
4923IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) {
4924  if (LocalID < NUM_PREDEF_IDENT_IDS)
4925    return LocalID;
4926
4927  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4928    = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
4929  assert(I != M.IdentifierRemap.end()
4930         && "Invalid index into identifier index remap");
4931
4932  return LocalID + I->second;
4933}
4934
4935bool ASTReader::ReadSLocEntry(int ID) {
4936  return ReadSLocEntryRecord(ID) != Success;
4937}
4938
4939Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) {
4940  return DecodeSelector(getGlobalSelectorID(M, LocalID));
4941}
4942
4943Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
4944  if (ID == 0)
4945    return Selector();
4946
4947  if (ID > SelectorsLoaded.size()) {
4948    Error("selector ID out of range in AST file");
4949    return Selector();
4950  }
4951
4952  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4953    // Load this selector from the selector table.
4954    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4955    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4956    Module &M = *I->second;
4957    ASTSelectorLookupTrait Trait(*this, M);
4958    unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
4959    SelectorsLoaded[ID - 1] =
4960      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
4961    if (DeserializationListener)
4962      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4963  }
4964
4965  return SelectorsLoaded[ID - 1];
4966}
4967
4968Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
4969  return DecodeSelector(ID);
4970}
4971
4972uint32_t ASTReader::GetNumExternalSelectors() {
4973  // ID 0 (the null selector) is considered an external selector.
4974  return getTotalNumSelectors() + 1;
4975}
4976
4977serialization::SelectorID
4978ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const {
4979  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
4980    return LocalID;
4981
4982  ContinuousRangeMap<uint32_t, int, 2>::iterator I
4983    = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
4984  assert(I != M.SelectorRemap.end()
4985         && "Invalid index into identifier index remap");
4986
4987  return LocalID + I->second;
4988}
4989
4990DeclarationName
4991ASTReader::ReadDeclarationName(Module &F,
4992                               const RecordData &Record, unsigned &Idx) {
4993  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4994  switch (Kind) {
4995  case DeclarationName::Identifier:
4996    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
4997
4998  case DeclarationName::ObjCZeroArgSelector:
4999  case DeclarationName::ObjCOneArgSelector:
5000  case DeclarationName::ObjCMultiArgSelector:
5001    return DeclarationName(ReadSelector(F, Record, Idx));
5002
5003  case DeclarationName::CXXConstructorName:
5004    return Context->DeclarationNames.getCXXConstructorName(
5005                          Context->getCanonicalType(readType(F, Record, Idx)));
5006
5007  case DeclarationName::CXXDestructorName:
5008    return Context->DeclarationNames.getCXXDestructorName(
5009                          Context->getCanonicalType(readType(F, Record, Idx)));
5010
5011  case DeclarationName::CXXConversionFunctionName:
5012    return Context->DeclarationNames.getCXXConversionFunctionName(
5013                          Context->getCanonicalType(readType(F, Record, Idx)));
5014
5015  case DeclarationName::CXXOperatorName:
5016    return Context->DeclarationNames.getCXXOperatorName(
5017                                       (OverloadedOperatorKind)Record[Idx++]);
5018
5019  case DeclarationName::CXXLiteralOperatorName:
5020    return Context->DeclarationNames.getCXXLiteralOperatorName(
5021                                       GetIdentifierInfo(F, Record, Idx));
5022
5023  case DeclarationName::CXXUsingDirective:
5024    return DeclarationName::getUsingDirectiveName();
5025  }
5026
5027  // Required to silence GCC warning
5028  return DeclarationName();
5029}
5030
5031void ASTReader::ReadDeclarationNameLoc(Module &F,
5032                                       DeclarationNameLoc &DNLoc,
5033                                       DeclarationName Name,
5034                                      const RecordData &Record, unsigned &Idx) {
5035  switch (Name.getNameKind()) {
5036  case DeclarationName::CXXConstructorName:
5037  case DeclarationName::CXXDestructorName:
5038  case DeclarationName::CXXConversionFunctionName:
5039    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
5040    break;
5041
5042  case DeclarationName::CXXOperatorName:
5043    DNLoc.CXXOperatorName.BeginOpNameLoc
5044        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5045    DNLoc.CXXOperatorName.EndOpNameLoc
5046        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5047    break;
5048
5049  case DeclarationName::CXXLiteralOperatorName:
5050    DNLoc.CXXLiteralOperatorName.OpNameLoc
5051        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
5052    break;
5053
5054  case DeclarationName::Identifier:
5055  case DeclarationName::ObjCZeroArgSelector:
5056  case DeclarationName::ObjCOneArgSelector:
5057  case DeclarationName::ObjCMultiArgSelector:
5058  case DeclarationName::CXXUsingDirective:
5059    break;
5060  }
5061}
5062
5063void ASTReader::ReadDeclarationNameInfo(Module &F,
5064                                        DeclarationNameInfo &NameInfo,
5065                                      const RecordData &Record, unsigned &Idx) {
5066  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
5067  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
5068  DeclarationNameLoc DNLoc;
5069  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
5070  NameInfo.setInfo(DNLoc);
5071}
5072
5073void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
5074                                  const RecordData &Record, unsigned &Idx) {
5075  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
5076  unsigned NumTPLists = Record[Idx++];
5077  Info.NumTemplParamLists = NumTPLists;
5078  if (NumTPLists) {
5079    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
5080    for (unsigned i=0; i != NumTPLists; ++i)
5081      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
5082  }
5083}
5084
5085TemplateName
5086ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
5087                            unsigned &Idx) {
5088  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
5089  switch (Kind) {
5090  case TemplateName::Template:
5091      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
5092
5093  case TemplateName::OverloadedTemplate: {
5094    unsigned size = Record[Idx++];
5095    UnresolvedSet<8> Decls;
5096    while (size--)
5097      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
5098
5099    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
5100  }
5101
5102  case TemplateName::QualifiedTemplate: {
5103    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5104    bool hasTemplKeyword = Record[Idx++];
5105    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
5106    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
5107  }
5108
5109  case TemplateName::DependentTemplate: {
5110    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
5111    if (Record[Idx++])  // isIdentifier
5112      return Context->getDependentTemplateName(NNS,
5113                                               GetIdentifierInfo(F, Record,
5114                                                                 Idx));
5115    return Context->getDependentTemplateName(NNS,
5116                                         (OverloadedOperatorKind)Record[Idx++]);
5117  }
5118
5119  case TemplateName::SubstTemplateTemplateParm: {
5120    TemplateTemplateParmDecl *param
5121      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5122    if (!param) return TemplateName();
5123    TemplateName replacement = ReadTemplateName(F, Record, Idx);
5124    return Context->getSubstTemplateTemplateParm(param, replacement);
5125  }
5126
5127  case TemplateName::SubstTemplateTemplateParmPack: {
5128    TemplateTemplateParmDecl *Param
5129      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
5130    if (!Param)
5131      return TemplateName();
5132
5133    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
5134    if (ArgPack.getKind() != TemplateArgument::Pack)
5135      return TemplateName();
5136
5137    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
5138  }
5139  }
5140
5141  assert(0 && "Unhandled template name kind!");
5142  return TemplateName();
5143}
5144
5145TemplateArgument
5146ASTReader::ReadTemplateArgument(Module &F,
5147                                const RecordData &Record, unsigned &Idx) {
5148  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
5149  switch (Kind) {
5150  case TemplateArgument::Null:
5151    return TemplateArgument();
5152  case TemplateArgument::Type:
5153    return TemplateArgument(readType(F, Record, Idx));
5154  case TemplateArgument::Declaration:
5155    return TemplateArgument(ReadDecl(F, Record, Idx));
5156  case TemplateArgument::Integral: {
5157    llvm::APSInt Value = ReadAPSInt(Record, Idx);
5158    QualType T = readType(F, Record, Idx);
5159    return TemplateArgument(Value, T);
5160  }
5161  case TemplateArgument::Template:
5162    return TemplateArgument(ReadTemplateName(F, Record, Idx));
5163  case TemplateArgument::TemplateExpansion: {
5164    TemplateName Name = ReadTemplateName(F, Record, Idx);
5165    llvm::Optional<unsigned> NumTemplateExpansions;
5166    if (unsigned NumExpansions = Record[Idx++])
5167      NumTemplateExpansions = NumExpansions - 1;
5168    return TemplateArgument(Name, NumTemplateExpansions);
5169  }
5170  case TemplateArgument::Expression:
5171    return TemplateArgument(ReadExpr(F));
5172  case TemplateArgument::Pack: {
5173    unsigned NumArgs = Record[Idx++];
5174    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
5175    for (unsigned I = 0; I != NumArgs; ++I)
5176      Args[I] = ReadTemplateArgument(F, Record, Idx);
5177    return TemplateArgument(Args, NumArgs);
5178  }
5179  }
5180
5181  assert(0 && "Unhandled template argument kind!");
5182  return TemplateArgument();
5183}
5184
5185TemplateParameterList *
5186ASTReader::ReadTemplateParameterList(Module &F,
5187                                     const RecordData &Record, unsigned &Idx) {
5188  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
5189  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
5190  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
5191
5192  unsigned NumParams = Record[Idx++];
5193  SmallVector<NamedDecl *, 16> Params;
5194  Params.reserve(NumParams);
5195  while (NumParams--)
5196    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
5197
5198  TemplateParameterList* TemplateParams =
5199    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
5200                                  Params.data(), Params.size(), RAngleLoc);
5201  return TemplateParams;
5202}
5203
5204void
5205ASTReader::
5206ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
5207                         Module &F, const RecordData &Record,
5208                         unsigned &Idx) {
5209  unsigned NumTemplateArgs = Record[Idx++];
5210  TemplArgs.reserve(NumTemplateArgs);
5211  while (NumTemplateArgs--)
5212    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
5213}
5214
5215/// \brief Read a UnresolvedSet structure.
5216void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
5217                                  const RecordData &Record, unsigned &Idx) {
5218  unsigned NumDecls = Record[Idx++];
5219  while (NumDecls--) {
5220    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
5221    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
5222    Set.addDecl(D, AS);
5223  }
5224}
5225
5226CXXBaseSpecifier
5227ASTReader::ReadCXXBaseSpecifier(Module &F,
5228                                const RecordData &Record, unsigned &Idx) {
5229  bool isVirtual = static_cast<bool>(Record[Idx++]);
5230  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
5231  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
5232  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
5233  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
5234  SourceRange Range = ReadSourceRange(F, Record, Idx);
5235  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
5236  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
5237                          EllipsisLoc);
5238  Result.setInheritConstructors(inheritConstructors);
5239  return Result;
5240}
5241
5242std::pair<CXXCtorInitializer **, unsigned>
5243ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
5244                                   unsigned &Idx) {
5245  CXXCtorInitializer **CtorInitializers = 0;
5246  unsigned NumInitializers = Record[Idx++];
5247  if (NumInitializers) {
5248    ASTContext &C = *getContext();
5249
5250    CtorInitializers
5251        = new (C) CXXCtorInitializer*[NumInitializers];
5252    for (unsigned i=0; i != NumInitializers; ++i) {
5253      TypeSourceInfo *BaseClassInfo = 0;
5254      bool IsBaseVirtual = false;
5255      FieldDecl *Member = 0;
5256      IndirectFieldDecl *IndirectMember = 0;
5257      CXXConstructorDecl *Target = 0;
5258
5259      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
5260      switch (Type) {
5261       case CTOR_INITIALIZER_BASE:
5262        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
5263        IsBaseVirtual = Record[Idx++];
5264        break;
5265
5266       case CTOR_INITIALIZER_DELEGATING:
5267        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
5268        break;
5269
5270       case CTOR_INITIALIZER_MEMBER:
5271        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
5272        break;
5273
5274       case CTOR_INITIALIZER_INDIRECT_MEMBER:
5275        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
5276        break;
5277      }
5278
5279      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
5280      Expr *Init = ReadExpr(F);
5281      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
5282      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
5283      bool IsWritten = Record[Idx++];
5284      unsigned SourceOrderOrNumArrayIndices;
5285      SmallVector<VarDecl *, 8> Indices;
5286      if (IsWritten) {
5287        SourceOrderOrNumArrayIndices = Record[Idx++];
5288      } else {
5289        SourceOrderOrNumArrayIndices = Record[Idx++];
5290        Indices.reserve(SourceOrderOrNumArrayIndices);
5291        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5292          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5293      }
5294
5295      CXXCtorInitializer *BOMInit;
5296      if (Type == CTOR_INITIALIZER_BASE) {
5297        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5298                                             LParenLoc, Init, RParenLoc,
5299                                             MemberOrEllipsisLoc);
5300      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5301        BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5302                                             Target, Init, RParenLoc);
5303      } else if (IsWritten) {
5304        if (Member)
5305          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5306                                               LParenLoc, Init, RParenLoc);
5307        else
5308          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5309                                               MemberOrEllipsisLoc, LParenLoc,
5310                                               Init, RParenLoc);
5311      } else {
5312        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5313                                             LParenLoc, Init, RParenLoc,
5314                                             Indices.data(), Indices.size());
5315      }
5316
5317      if (IsWritten)
5318        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5319      CtorInitializers[i] = BOMInit;
5320    }
5321  }
5322
5323  return std::make_pair(CtorInitializers, NumInitializers);
5324}
5325
5326NestedNameSpecifier *
5327ASTReader::ReadNestedNameSpecifier(Module &F,
5328                                   const RecordData &Record, unsigned &Idx) {
5329  unsigned N = Record[Idx++];
5330  NestedNameSpecifier *NNS = 0, *Prev = 0;
5331  for (unsigned I = 0; I != N; ++I) {
5332    NestedNameSpecifier::SpecifierKind Kind
5333      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5334    switch (Kind) {
5335    case NestedNameSpecifier::Identifier: {
5336      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5337      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5338      break;
5339    }
5340
5341    case NestedNameSpecifier::Namespace: {
5342      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5343      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5344      break;
5345    }
5346
5347    case NestedNameSpecifier::NamespaceAlias: {
5348      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5349      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5350      break;
5351    }
5352
5353    case NestedNameSpecifier::TypeSpec:
5354    case NestedNameSpecifier::TypeSpecWithTemplate: {
5355      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5356      if (!T)
5357        return 0;
5358
5359      bool Template = Record[Idx++];
5360      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5361      break;
5362    }
5363
5364    case NestedNameSpecifier::Global: {
5365      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5366      // No associated value, and there can't be a prefix.
5367      break;
5368    }
5369    }
5370    Prev = NNS;
5371  }
5372  return NNS;
5373}
5374
5375NestedNameSpecifierLoc
5376ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5377                                      unsigned &Idx) {
5378  unsigned N = Record[Idx++];
5379  NestedNameSpecifierLocBuilder Builder;
5380  for (unsigned I = 0; I != N; ++I) {
5381    NestedNameSpecifier::SpecifierKind Kind
5382      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5383    switch (Kind) {
5384    case NestedNameSpecifier::Identifier: {
5385      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
5386      SourceRange Range = ReadSourceRange(F, Record, Idx);
5387      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5388      break;
5389    }
5390
5391    case NestedNameSpecifier::Namespace: {
5392      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5393      SourceRange Range = ReadSourceRange(F, Record, Idx);
5394      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5395      break;
5396    }
5397
5398    case NestedNameSpecifier::NamespaceAlias: {
5399      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5400      SourceRange Range = ReadSourceRange(F, Record, Idx);
5401      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5402      break;
5403    }
5404
5405    case NestedNameSpecifier::TypeSpec:
5406    case NestedNameSpecifier::TypeSpecWithTemplate: {
5407      bool Template = Record[Idx++];
5408      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5409      if (!T)
5410        return NestedNameSpecifierLoc();
5411      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5412
5413      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5414      Builder.Extend(*Context,
5415                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5416                     T->getTypeLoc(), ColonColonLoc);
5417      break;
5418    }
5419
5420    case NestedNameSpecifier::Global: {
5421      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5422      Builder.MakeGlobal(*Context, ColonColonLoc);
5423      break;
5424    }
5425    }
5426  }
5427
5428  return Builder.getWithLocInContext(*Context);
5429}
5430
5431SourceRange
5432ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5433                           unsigned &Idx) {
5434  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5435  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5436  return SourceRange(beg, end);
5437}
5438
5439/// \brief Read an integral value
5440llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5441  unsigned BitWidth = Record[Idx++];
5442  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5443  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5444  Idx += NumWords;
5445  return Result;
5446}
5447
5448/// \brief Read a signed integral value
5449llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5450  bool isUnsigned = Record[Idx++];
5451  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5452}
5453
5454/// \brief Read a floating-point value
5455llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5456  return llvm::APFloat(ReadAPInt(Record, Idx));
5457}
5458
5459// \brief Read a string
5460std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5461  unsigned Len = Record[Idx++];
5462  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5463  Idx += Len;
5464  return Result;
5465}
5466
5467VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5468                                         unsigned &Idx) {
5469  unsigned Major = Record[Idx++];
5470  unsigned Minor = Record[Idx++];
5471  unsigned Subminor = Record[Idx++];
5472  if (Minor == 0)
5473    return VersionTuple(Major);
5474  if (Subminor == 0)
5475    return VersionTuple(Major, Minor - 1);
5476  return VersionTuple(Major, Minor - 1, Subminor - 1);
5477}
5478
5479CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5480                                          const RecordData &Record,
5481                                          unsigned &Idx) {
5482  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5483  return CXXTemporary::Create(*Context, Decl);
5484}
5485
5486DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5487  return Diag(SourceLocation(), DiagID);
5488}
5489
5490DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5491  return Diags.Report(Loc, DiagID);
5492}
5493
5494/// \brief Retrieve the identifier table associated with the
5495/// preprocessor.
5496IdentifierTable &ASTReader::getIdentifierTable() {
5497  assert(PP && "Forgot to set Preprocessor ?");
5498  return PP->getIdentifierTable();
5499}
5500
5501/// \brief Record that the given ID maps to the given switch-case
5502/// statement.
5503void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5504  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5505  SwitchCaseStmts[ID] = SC;
5506}
5507
5508/// \brief Retrieve the switch-case statement with the given ID.
5509SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5510  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5511  return SwitchCaseStmts[ID];
5512}
5513
5514void ASTReader::ClearSwitchCaseIDs() {
5515  SwitchCaseStmts.clear();
5516}
5517
5518void ASTReader::FinishedDeserializing() {
5519  assert(NumCurrentElementsDeserializing &&
5520         "FinishedDeserializing not paired with StartedDeserializing");
5521  if (NumCurrentElementsDeserializing == 1) {
5522    // If any identifiers with corresponding top-level declarations have
5523    // been loaded, load those declarations now.
5524    while (!PendingIdentifierInfos.empty()) {
5525      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5526                              PendingIdentifierInfos.front().DeclIDs, true);
5527      PendingIdentifierInfos.pop_front();
5528    }
5529
5530    // Ready to load previous declarations of Decls that were delayed.
5531    while (!PendingPreviousDecls.empty()) {
5532      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5533                                PendingPreviousDecls.front().second);
5534      PendingPreviousDecls.pop_front();
5535    }
5536
5537    // We are not in recursive loading, so it's safe to pass the "interesting"
5538    // decls to the consumer.
5539    if (Consumer)
5540      PassInterestingDeclsToConsumer();
5541
5542    assert(PendingForwardRefs.size() == 0 &&
5543           "Some forward refs did not get linked to the definition!");
5544  }
5545  --NumCurrentElementsDeserializing;
5546}
5547
5548ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
5549                     StringRef isysroot, bool DisableValidation,
5550                     bool DisableStatCache)
5551  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5552    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5553    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
5554    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5555    RelocatablePCH(false), isysroot(isysroot),
5556    DisableValidation(DisableValidation),
5557    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5558    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5559    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5560    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5561    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5562    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5563    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5564    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5565    NumCXXBaseSpecifiersLoaded(0)
5566{
5567  SourceMgr.setExternalSLocEntrySource(this);
5568}
5569
5570ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
5571                     Diagnostic &Diags, StringRef isysroot,
5572                     bool DisableValidation, bool DisableStatCache)
5573  : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
5574    Diags(Diags), SemaObj(0), PP(0), Context(0),
5575    Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()),
5576    RelocatablePCH(false), isysroot(isysroot),
5577    DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
5578    NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
5579    TotalNumSLocEntries(0), NumStatementsRead(0),
5580    TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
5581    NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
5582    TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5583    TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
5584    TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
5585    NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
5586{
5587  SourceMgr.setExternalSLocEntrySource(this);
5588}
5589
5590ASTReader::~ASTReader() {
5591  // Delete all visible decl lookup tables
5592  for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5593                                       E = DeclContextOffsets.end();
5594       I != E; ++I) {
5595    for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5596         J != F; ++J) {
5597      if (J->NameLookupTableData)
5598        delete static_cast<ASTDeclContextNameLookupTable*>(
5599            J->NameLookupTableData);
5600    }
5601  }
5602  for (DeclContextVisibleUpdatesPending::iterator
5603           I = PendingVisibleUpdates.begin(),
5604           E = PendingVisibleUpdates.end();
5605       I != E; ++I) {
5606    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5607                                             F = I->second.end();
5608         J != F; ++J)
5609      delete static_cast<ASTDeclContextNameLookupTable*>(J->first);
5610  }
5611}
5612
5613Module::Module(ModuleKind Kind)
5614  : Kind(Kind), DirectlyImported(false), SizeInBits(0),
5615    LocalNumSLocEntries(0), SLocEntryBaseID(0),
5616    SLocEntryBaseOffset(0), SLocEntryOffsets(0),
5617    SLocFileOffsets(0), LocalNumIdentifiers(0),
5618    IdentifierOffsets(0), BaseIdentifierID(0), IdentifierTableData(0),
5619    IdentifierLookupTable(0), BasePreprocessedEntityID(0),
5620    LocalNumMacroDefinitions(0), MacroDefinitionOffsets(0),
5621    BaseMacroDefinitionID(0), LocalNumHeaderFileInfos(0),
5622    HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
5623    HeaderFileFrameworkStrings(0),
5624    LocalNumSelectors(0), SelectorOffsets(0), BaseSelectorID(0),
5625    SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5626    DeclOffsets(0), BaseDeclID(0),
5627    LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5628    LocalNumTypes(0), TypeOffsets(0), BaseTypeIndex(0), StatCache(0),
5629    NumPreallocatedPreprocessingEntities(0)
5630{}
5631
5632Module::~Module() {
5633  delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5634  delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5635  delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5636}
5637
5638template<typename Key, typename Offset, unsigned InitialCapacity>
5639static void
5640dumpLocalRemap(StringRef Name,
5641               const ContinuousRangeMap<Key, Offset, InitialCapacity> &Map) {
5642  if (Map.begin() == Map.end())
5643    return;
5644
5645  typedef ContinuousRangeMap<Key, Offset, InitialCapacity> MapType;
5646  llvm::errs() << "  " << Name << ":\n";
5647  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
5648       I != IEnd; ++I) {
5649    llvm::errs() << "    " << I->first << " -> " << I->second
5650    << "\n";
5651  }
5652}
5653
5654void Module::dump() {
5655  llvm::errs() << "\nModule: " << FileName << "\n";
5656  if (!Imports.empty()) {
5657    llvm::errs() << "  Imports: ";
5658    for (unsigned I = 0, N = Imports.size(); I != N; ++I) {
5659      if (I)
5660        llvm::errs() << ", ";
5661      llvm::errs() << Imports[I]->FileName;
5662    }
5663    llvm::errs() << "\n";
5664  }
5665
5666  // Remapping tables.
5667  llvm::errs() << "  Base source location offset: " << SLocEntryBaseOffset
5668               << '\n';
5669  dumpLocalRemap("Source location offset local -> global map", SLocRemap);
5670
5671  llvm::errs() << "  Base identifier ID: " << BaseIdentifierID << '\n'
5672               << "  Number of identifiers: " << LocalNumIdentifiers << '\n';
5673  dumpLocalRemap("Identifier ID local -> global map", IdentifierRemap);
5674
5675  llvm::errs() << "  Base selector ID: " << BaseSelectorID << '\n'
5676               << "  Number of selectors: " << LocalNumSelectors << '\n';
5677  dumpLocalRemap("Selector ID local -> global map", SelectorRemap);
5678
5679  llvm::errs() << "  Base preprocessed entity ID: " << BasePreprocessedEntityID
5680               << '\n'
5681               << "  Number of preprocessed entities: "
5682               << NumPreallocatedPreprocessingEntities << '\n';
5683  dumpLocalRemap("Preprocessed entity ID local -> global map",
5684                 PreprocessedEntityRemap);
5685
5686  llvm::errs() << "  Base macro definition ID: " << BaseMacroDefinitionID
5687               << '\n'
5688               << "  Number of macro definitions: " << LocalNumMacroDefinitions
5689               << '\n';
5690  dumpLocalRemap("Macro definition ID local -> global map",
5691                 MacroDefinitionRemap);
5692
5693  llvm::errs() << "  Base type index: " << BaseTypeIndex << '\n'
5694               << "  Number of types: " << LocalNumTypes << '\n';
5695  dumpLocalRemap("Type index local -> global map", TypeRemap);
5696
5697  llvm::errs() << "  Base decl ID: " << BaseDeclID << '\n'
5698               << "  Number of decls: " << LocalNumDecls << '\n';
5699  dumpLocalRemap("Decl ID local -> global map", DeclRemap);
5700}
5701
5702Module *ModuleManager::lookup(StringRef Name) {
5703  const FileEntry *Entry = FileMgr.getFile(Name);
5704  return Modules[Entry];
5705}
5706
5707llvm::MemoryBuffer *ModuleManager::lookupBuffer(StringRef Name) {
5708  const FileEntry *Entry = FileMgr.getFile(Name);
5709  return InMemoryBuffers[Entry];
5710}
5711
5712/// \brief Creates a new module and adds it to the list of known modules
5713Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type,
5714                                 Module *ImportedBy) {
5715  Module *Current = new Module(Type);
5716  Current->FileName = FileName.str();
5717  Chain.push_back(Current);
5718
5719  const FileEntry *Entry = FileMgr.getFile(FileName);
5720  // FIXME: Check whether we already loaded this module, before
5721  Modules[Entry] = Current;
5722
5723  if (ImportedBy) {
5724    Current->ImportedBy.insert(ImportedBy);
5725    ImportedBy->Imports.insert(Current);
5726  } else {
5727    Current->DirectlyImported = true;
5728  }
5729
5730  return *Current;
5731}
5732
5733void ModuleManager::addInMemoryBuffer(StringRef FileName,
5734  llvm::MemoryBuffer *Buffer) {
5735
5736  const FileEntry *Entry = FileMgr.getVirtualFile(FileName,
5737    Buffer->getBufferSize(), 0);
5738  InMemoryBuffers[Entry] = Buffer;
5739}
5740/// \brief Exports the list of loaded modules with their corresponding names
5741void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
5742  Target.reserve(size());
5743  for (ModuleConstIterator I = Chain.begin(), E = Chain.end();
5744       I != E; ++I) {
5745    Target.push_back(ModuleOffset((*I)->SLocEntryBaseOffset,
5746                                  (*I)->FileName));
5747  }
5748  std::sort(Target.begin(), Target.end());
5749}
5750
5751ModuleManager::ModuleManager(const FileSystemOptions &FSO) : FileMgr(FSO) { }
5752
5753ModuleManager::~ModuleManager() {
5754  for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5755    delete Chain[e - i - 1];
5756}
5757