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