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