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