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