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