ASTReader.cpp revision 48d2c3f7c3ca48da05436afdc8426a245294ee65 
1//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file defines the ASTReader class, which reads AST files.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Serialization/ASTReader.h"
15#include "clang/Serialization/ASTDeserializationListener.h"
16#include "ASTCommon.h"
17#include "clang/Frontend/FrontendDiagnostic.h"
18#include "clang/Frontend/Utils.h"
19#include "clang/Sema/Sema.h"
20#include "clang/Sema/Scope.h"
21#include "clang/AST/ASTConsumer.h"
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/DeclTemplate.h"
24#include "clang/AST/Expr.h"
25#include "clang/AST/ExprCXX.h"
26#include "clang/AST/NestedNameSpecifier.h"
27#include "clang/AST/Type.h"
28#include "clang/AST/TypeLocVisitor.h"
29#include "clang/Lex/MacroInfo.h"
30#include "clang/Lex/PreprocessingRecord.h"
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Lex/HeaderSearch.h"
33#include "clang/Basic/OnDiskHashTable.h"
34#include "clang/Basic/SourceManager.h"
35#include "clang/Basic/SourceManagerInternals.h"
36#include "clang/Basic/FileManager.h"
37#include "clang/Basic/FileSystemStatCache.h"
38#include "clang/Basic/TargetInfo.h"
39#include "clang/Basic/Version.h"
40#include "clang/Basic/VersionTuple.h"
41#include "llvm/ADT/StringExtras.h"
42#include "llvm/Bitcode/BitstreamReader.h"
43#include "llvm/Support/MemoryBuffer.h"
44#include "llvm/Support/ErrorHandling.h"
45#include "llvm/Support/FileSystem.h"
46#include "llvm/Support/Path.h"
47#include "llvm/Support/system_error.h"
48#include <algorithm>
49#include <iterator>
50#include <cstdio>
51#include <sys/stat.h>
52#include <iostream>
53
54using namespace clang;
55using namespace clang::serialization;
56
57//===----------------------------------------------------------------------===//
58// PCH validator implementation
59//===----------------------------------------------------------------------===//
60
61ASTReaderListener::~ASTReaderListener() {}
62
63bool
64PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) {
65  const LangOptions &PPLangOpts = PP.getLangOptions();
66#define PARSE_LANGOPT_BENIGN(Option)
67#define PARSE_LANGOPT_IMPORTANT(Option, DiagID)                    \
68  if (PPLangOpts.Option != LangOpts.Option) {                      \
69    Reader.Diag(DiagID) << LangOpts.Option << PPLangOpts.Option;   \
70    return true;                                                   \
71  }
72
73  PARSE_LANGOPT_BENIGN(Trigraphs);
74  PARSE_LANGOPT_BENIGN(BCPLComment);
75  PARSE_LANGOPT_BENIGN(DollarIdents);
76  PARSE_LANGOPT_BENIGN(AsmPreprocessor);
77  PARSE_LANGOPT_IMPORTANT(GNUMode, diag::warn_pch_gnu_extensions);
78  PARSE_LANGOPT_IMPORTANT(GNUKeywords, diag::warn_pch_gnu_keywords);
79  PARSE_LANGOPT_BENIGN(ImplicitInt);
80  PARSE_LANGOPT_BENIGN(Digraphs);
81  PARSE_LANGOPT_BENIGN(HexFloats);
82  PARSE_LANGOPT_IMPORTANT(C99, diag::warn_pch_c99);
83  PARSE_LANGOPT_IMPORTANT(C1X, diag::warn_pch_c1x);
84  PARSE_LANGOPT_IMPORTANT(Microsoft, diag::warn_pch_microsoft_extensions);
85  PARSE_LANGOPT_BENIGN(MSCVersion);
86  PARSE_LANGOPT_IMPORTANT(CPlusPlus, diag::warn_pch_cplusplus);
87  PARSE_LANGOPT_IMPORTANT(CPlusPlus0x, diag::warn_pch_cplusplus0x);
88  PARSE_LANGOPT_BENIGN(CXXOperatorName);
89  PARSE_LANGOPT_IMPORTANT(ObjC1, diag::warn_pch_objective_c);
90  PARSE_LANGOPT_IMPORTANT(ObjC2, diag::warn_pch_objective_c2);
91  PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi);
92  PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI2, diag::warn_pch_nonfragile_abi2);
93  PARSE_LANGOPT_IMPORTANT(AppleKext, diag::warn_pch_apple_kext);
94  PARSE_LANGOPT_IMPORTANT(ObjCDefaultSynthProperties,
95                          diag::warn_pch_objc_auto_properties);
96  PARSE_LANGOPT_BENIGN(ObjCInferRelatedResultType)
97  PARSE_LANGOPT_IMPORTANT(NoConstantCFStrings,
98                          diag::warn_pch_no_constant_cfstrings);
99  PARSE_LANGOPT_BENIGN(PascalStrings);
100  PARSE_LANGOPT_BENIGN(WritableStrings);
101  PARSE_LANGOPT_IMPORTANT(LaxVectorConversions,
102                          diag::warn_pch_lax_vector_conversions);
103  PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec);
104  PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions);
105  PARSE_LANGOPT_IMPORTANT(ObjCExceptions, diag::warn_pch_objc_exceptions);
106  PARSE_LANGOPT_IMPORTANT(CXXExceptions, diag::warn_pch_cxx_exceptions);
107  PARSE_LANGOPT_IMPORTANT(SjLjExceptions, diag::warn_pch_sjlj_exceptions);
108  PARSE_LANGOPT_IMPORTANT(MSBitfields, diag::warn_pch_ms_bitfields);
109  PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime);
110  PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding);
111  PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins);
112  PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics,
113                          diag::warn_pch_thread_safe_statics);
114  PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads);
115  PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks);
116  PARSE_LANGOPT_BENIGN(EmitAllDecls);
117  PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno);
118  PARSE_LANGOPT_BENIGN(getSignedOverflowBehavior());
119  PARSE_LANGOPT_IMPORTANT(HeinousExtensions,
120                          diag::warn_pch_heinous_extensions);
121  // FIXME: Most of the options below are benign if the macro wasn't
122  // used. Unfortunately, this means that a PCH compiled without
123  // optimization can't be used with optimization turned on, even
124  // though the only thing that changes is whether __OPTIMIZE__ was
125  // defined... but if __OPTIMIZE__ never showed up in the header, it
126  // doesn't matter. We could consider making this some special kind
127  // of check.
128  PARSE_LANGOPT_IMPORTANT(Optimize, diag::warn_pch_optimize);
129  PARSE_LANGOPT_IMPORTANT(OptimizeSize, diag::warn_pch_optimize_size);
130  PARSE_LANGOPT_IMPORTANT(Static, diag::warn_pch_static);
131  PARSE_LANGOPT_IMPORTANT(PICLevel, diag::warn_pch_pic_level);
132  PARSE_LANGOPT_IMPORTANT(GNUInline, diag::warn_pch_gnu_inline);
133  PARSE_LANGOPT_IMPORTANT(NoInline, diag::warn_pch_no_inline);
134  PARSE_LANGOPT_IMPORTANT(Deprecated, diag::warn_pch_deprecated);
135  PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control);
136  PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed);
137  PARSE_LANGOPT_IMPORTANT(ShortWChar, diag::warn_pch_short_wchar);
138  PARSE_LANGOPT_IMPORTANT(ShortEnums, diag::warn_pch_short_enums);
139  if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) {
140    Reader.Diag(diag::warn_pch_gc_mode)
141      << LangOpts.getGCMode() << PPLangOpts.getGCMode();
142    return true;
143  }
144  PARSE_LANGOPT_BENIGN(getVisibilityMode());
145  PARSE_LANGOPT_IMPORTANT(getStackProtectorMode(),
146                          diag::warn_pch_stack_protector);
147  PARSE_LANGOPT_BENIGN(InstantiationDepth);
148  PARSE_LANGOPT_IMPORTANT(OpenCL, diag::warn_pch_opencl);
149  PARSE_LANGOPT_IMPORTANT(CUDA, diag::warn_pch_cuda);
150  PARSE_LANGOPT_BENIGN(CatchUndefined);
151  PARSE_LANGOPT_BENIGN(DefaultFPContract);
152  PARSE_LANGOPT_IMPORTANT(ElideConstructors, diag::warn_pch_elide_constructors);
153  PARSE_LANGOPT_BENIGN(SpellChecking);
154  PARSE_LANGOPT_IMPORTANT(ObjCAutoRefCount, diag::warn_pch_auto_ref_count);
155  PARSE_LANGOPT_BENIGN(ObjCInferRelatedReturnType);
156#undef PARSE_LANGOPT_IMPORTANT
157#undef PARSE_LANGOPT_BENIGN
158
159  return false;
160}
161
162bool PCHValidator::ReadTargetTriple(StringRef Triple) {
163  if (Triple == PP.getTargetInfo().getTriple().str())
164    return false;
165
166  Reader.Diag(diag::warn_pch_target_triple)
167    << Triple << PP.getTargetInfo().getTriple().str();
168  return true;
169}
170
171namespace {
172  struct EmptyStringRef {
173    bool operator ()(StringRef r) const { return r.empty(); }
174  };
175  struct EmptyBlock {
176    bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();}
177  };
178}
179
180static bool EqualConcatenations(SmallVector<StringRef, 2> L,
181                                PCHPredefinesBlocks R) {
182  // First, sum up the lengths.
183  unsigned LL = 0, RL = 0;
184  for (unsigned I = 0, N = L.size(); I != N; ++I) {
185    LL += L[I].size();
186  }
187  for (unsigned I = 0, N = R.size(); I != N; ++I) {
188    RL += R[I].Data.size();
189  }
190  if (LL != RL)
191    return false;
192  if (LL == 0 && RL == 0)
193    return true;
194
195  // Kick out empty parts, they confuse the algorithm below.
196  L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end());
197  R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end());
198
199  // Do it the hard way. At this point, both vectors must be non-empty.
200  StringRef LR = L[0], RR = R[0].Data;
201  unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size();
202  (void) RN;
203  for (;;) {
204    // Compare the current pieces.
205    if (LR.size() == RR.size()) {
206      // If they're the same length, it's pretty easy.
207      if (LR != RR)
208        return false;
209      // Both pieces are done, advance.
210      ++LI;
211      ++RI;
212      // If either string is done, they're both done, since they're the same
213      // length.
214      if (LI == LN) {
215        assert(RI == RN && "Strings not the same length after all?");
216        return true;
217      }
218      LR = L[LI];
219      RR = R[RI].Data;
220    } else if (LR.size() < RR.size()) {
221      // Right piece is longer.
222      if (!RR.startswith(LR))
223        return false;
224      ++LI;
225      assert(LI != LN && "Strings not the same length after all?");
226      RR = RR.substr(LR.size());
227      LR = L[LI];
228    } else {
229      // Left piece is longer.
230      if (!LR.startswith(RR))
231        return false;
232      ++RI;
233      assert(RI != RN && "Strings not the same length after all?");
234      LR = LR.substr(RR.size());
235      RR = R[RI].Data;
236    }
237  }
238}
239
240static std::pair<FileID, StringRef::size_type>
241FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) {
242  std::pair<FileID, StringRef::size_type> Res;
243  for (unsigned I = 0, N = Buffers.size(); I != N; ++I) {
244    Res.second = Buffers[I].Data.find(MacroDef);
245    if (Res.second != StringRef::npos) {
246      Res.first = Buffers[I].BufferID;
247      break;
248    }
249  }
250  return Res;
251}
252
253bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
254                                        StringRef OriginalFileName,
255                                        std::string &SuggestedPredefines,
256                                        FileManager &FileMgr) {
257  // We are in the context of an implicit include, so the predefines buffer will
258  // have a #include entry for the PCH file itself (as normalized by the
259  // preprocessor initialization). Find it and skip over it in the checking
260  // below.
261  llvm::SmallString<256> PCHInclude;
262  PCHInclude += "#include \"";
263  PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr);
264  PCHInclude += "\"\n";
265  std::pair<StringRef,StringRef> Split =
266    StringRef(PP.getPredefines()).split(PCHInclude.str());
267  StringRef Left =  Split.first, Right = Split.second;
268  if (Left == PP.getPredefines()) {
269    Error("Missing PCH include entry!");
270    return true;
271  }
272
273  // If the concatenation of all the PCH buffers is equal to the adjusted
274  // command line, we're done.
275  SmallVector<StringRef, 2> CommandLine;
276  CommandLine.push_back(Left);
277  CommandLine.push_back(Right);
278  if (EqualConcatenations(CommandLine, Buffers))
279    return false;
280
281  SourceManager &SourceMgr = PP.getSourceManager();
282
283  // The predefines buffers are different. Determine what the differences are,
284  // and whether they require us to reject the PCH file.
285  SmallVector<StringRef, 8> PCHLines;
286  for (unsigned I = 0, N = Buffers.size(); I != N; ++I)
287    Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
288
289  SmallVector<StringRef, 8> CmdLineLines;
290  Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
291
292  // Pick out implicit #includes after the PCH and don't consider them for
293  // validation; we will insert them into SuggestedPredefines so that the
294  // preprocessor includes them.
295  std::string IncludesAfterPCH;
296  SmallVector<StringRef, 8> AfterPCHLines;
297  Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false);
298  for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) {
299    if (AfterPCHLines[i].startswith("#include ")) {
300      IncludesAfterPCH += AfterPCHLines[i];
301      IncludesAfterPCH += '\n';
302    } else {
303      CmdLineLines.push_back(AfterPCHLines[i]);
304    }
305  }
306
307  // Make sure we add the includes last into SuggestedPredefines before we
308  // exit this function.
309  struct AddIncludesRAII {
310    std::string &SuggestedPredefines;
311    std::string &IncludesAfterPCH;
312
313    AddIncludesRAII(std::string &SuggestedPredefines,
314                    std::string &IncludesAfterPCH)
315      : SuggestedPredefines(SuggestedPredefines),
316        IncludesAfterPCH(IncludesAfterPCH) { }
317    ~AddIncludesRAII() {
318      SuggestedPredefines += IncludesAfterPCH;
319    }
320  } AddIncludes(SuggestedPredefines, IncludesAfterPCH);
321
322  // Sort both sets of predefined buffer lines, since we allow some extra
323  // definitions and they may appear at any point in the output.
324  std::sort(CmdLineLines.begin(), CmdLineLines.end());
325  std::sort(PCHLines.begin(), PCHLines.end());
326
327  // Determine which predefines that were used to build the PCH file are missing
328  // from the command line.
329  std::vector<StringRef> MissingPredefines;
330  std::set_difference(PCHLines.begin(), PCHLines.end(),
331                      CmdLineLines.begin(), CmdLineLines.end(),
332                      std::back_inserter(MissingPredefines));
333
334  bool MissingDefines = false;
335  bool ConflictingDefines = false;
336  for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) {
337    StringRef Missing = MissingPredefines[I];
338    if (Missing.startswith("#include ")) {
339      // An -include was specified when generating the PCH; it is included in
340      // the PCH, just ignore it.
341      continue;
342    }
343    if (!Missing.startswith("#define ")) {
344      Reader.Diag(diag::warn_pch_compiler_options_mismatch);
345      return true;
346    }
347
348    // This is a macro definition. Determine the name of the macro we're
349    // defining.
350    std::string::size_type StartOfMacroName = strlen("#define ");
351    std::string::size_type EndOfMacroName
352      = Missing.find_first_of("( \n\r", StartOfMacroName);
353    assert(EndOfMacroName != std::string::npos &&
354           "Couldn't find the end of the macro name");
355    StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName);
356
357    // Determine whether this macro was given a different definition on the
358    // command line.
359    std::string MacroDefStart = "#define " + MacroName.str();
360    std::string::size_type MacroDefLen = MacroDefStart.size();
361    SmallVector<StringRef, 8>::iterator ConflictPos
362      = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(),
363                         MacroDefStart);
364    for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) {
365      if (!ConflictPos->startswith(MacroDefStart)) {
366        // Different macro; we're done.
367        ConflictPos = CmdLineLines.end();
368        break;
369      }
370
371      assert(ConflictPos->size() > MacroDefLen &&
372             "Invalid #define in predefines buffer?");
373      if ((*ConflictPos)[MacroDefLen] != ' ' &&
374          (*ConflictPos)[MacroDefLen] != '(')
375        continue; // Longer macro name; keep trying.
376
377      // We found a conflicting macro definition.
378      break;
379    }
380
381    if (ConflictPos != CmdLineLines.end()) {
382      Reader.Diag(diag::warn_cmdline_conflicting_macro_def)
383          << MacroName;
384
385      // Show the definition of this macro within the PCH file.
386      std::pair<FileID, StringRef::size_type> MacroLoc =
387          FindMacro(Buffers, Missing);
388      assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
389      SourceLocation PCHMissingLoc =
390          SourceMgr.getLocForStartOfFile(MacroLoc.first)
391            .getFileLocWithOffset(MacroLoc.second);
392      Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName;
393
394      ConflictingDefines = true;
395      continue;
396    }
397
398    // If the macro doesn't conflict, then we'll just pick up the macro
399    // definition from the PCH file. Warn the user that they made a mistake.
400    if (ConflictingDefines)
401      continue; // Don't complain if there are already conflicting defs
402
403    if (!MissingDefines) {
404      Reader.Diag(diag::warn_cmdline_missing_macro_defs);
405      MissingDefines = true;
406    }
407
408    // Show the definition of this macro within the PCH file.
409    std::pair<FileID, StringRef::size_type> MacroLoc =
410        FindMacro(Buffers, Missing);
411    assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!");
412    SourceLocation PCHMissingLoc =
413        SourceMgr.getLocForStartOfFile(MacroLoc.first)
414          .getFileLocWithOffset(MacroLoc.second);
415    Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch);
416  }
417
418  if (ConflictingDefines)
419    return true;
420
421  // Determine what predefines were introduced based on command-line
422  // parameters that were not present when building the PCH
423  // file. Extra #defines are okay, so long as the identifiers being
424  // defined were not used within the precompiled header.
425  std::vector<StringRef> ExtraPredefines;
426  std::set_difference(CmdLineLines.begin(), CmdLineLines.end(),
427                      PCHLines.begin(), PCHLines.end(),
428                      std::back_inserter(ExtraPredefines));
429  for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) {
430    StringRef &Extra = ExtraPredefines[I];
431    if (!Extra.startswith("#define ")) {
432      Reader.Diag(diag::warn_pch_compiler_options_mismatch);
433      return true;
434    }
435
436    // This is an extra macro definition. Determine the name of the
437    // macro we're defining.
438    std::string::size_type StartOfMacroName = strlen("#define ");
439    std::string::size_type EndOfMacroName
440      = Extra.find_first_of("( \n\r", StartOfMacroName);
441    assert(EndOfMacroName != std::string::npos &&
442           "Couldn't find the end of the macro name");
443    StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName);
444
445    // Check whether this name was used somewhere in the PCH file. If
446    // so, defining it as a macro could change behavior, so we reject
447    // the PCH file.
448    if (IdentifierInfo *II = Reader.get(MacroName)) {
449      Reader.Diag(diag::warn_macro_name_used_in_pch) << II;
450      return true;
451    }
452
453    // Add this definition to the suggested predefines buffer.
454    SuggestedPredefines += Extra;
455    SuggestedPredefines += '\n';
456  }
457
458  // If we get here, it's because the predefines buffer had compatible
459  // contents. Accept the PCH file.
460  return false;
461}
462
463void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI,
464                                      unsigned ID) {
465  PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID);
466  ++NumHeaderInfos;
467}
468
469void PCHValidator::ReadCounter(unsigned Value) {
470  PP.setCounterValue(Value);
471}
472
473//===----------------------------------------------------------------------===//
474// AST reader implementation
475//===----------------------------------------------------------------------===//
476
477void
478ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) {
479  DeserializationListener = Listener;
480}
481
482
483namespace {
484class ASTSelectorLookupTrait {
485  ASTReader &Reader;
486  Module &F;
487
488public:
489  struct data_type {
490    SelectorID ID;
491    ObjCMethodList Instance, Factory;
492  };
493
494  typedef Selector external_key_type;
495  typedef external_key_type internal_key_type;
496
497  ASTSelectorLookupTrait(ASTReader &Reader, Module &F)
498    : Reader(Reader), F(F) { }
499
500  static bool EqualKey(const internal_key_type& a,
501                       const internal_key_type& b) {
502    return a == b;
503  }
504
505  static unsigned ComputeHash(Selector Sel) {
506    return serialization::ComputeHash(Sel);
507  }
508
509  // This hopefully will just get inlined and removed by the optimizer.
510  static const internal_key_type&
511  GetInternalKey(const external_key_type& x) { return x; }
512
513  static std::pair<unsigned, unsigned>
514  ReadKeyDataLength(const unsigned char*& d) {
515    using namespace clang::io;
516    unsigned KeyLen = ReadUnalignedLE16(d);
517    unsigned DataLen = ReadUnalignedLE16(d);
518    return std::make_pair(KeyLen, DataLen);
519  }
520
521  internal_key_type ReadKey(const unsigned char* d, unsigned) {
522    using namespace clang::io;
523    SelectorTable &SelTable = Reader.getContext()->Selectors;
524    unsigned N = ReadUnalignedLE16(d);
525    IdentifierInfo *FirstII
526      = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d));
527    if (N == 0)
528      return SelTable.getNullarySelector(FirstII);
529    else if (N == 1)
530      return SelTable.getUnarySelector(FirstII);
531
532    SmallVector<IdentifierInfo *, 16> Args;
533    Args.push_back(FirstII);
534    for (unsigned I = 1; I != N; ++I)
535      Args.push_back(Reader.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  Module &F;
599
600  // If we know the IdentifierInfo in advance, it is here and we will
601  // not build a new one. Used when deserializing information about an
602  // identifier that was constructed before the AST file was read.
603  IdentifierInfo *KnownII;
604
605public:
606  typedef IdentifierInfo * data_type;
607
608  typedef const std::pair<const char*, unsigned> external_key_type;
609
610  typedef external_key_type internal_key_type;
611
612  ASTIdentifierLookupTrait(ASTReader &Reader, Module &F,
613                           IdentifierInfo *II = 0)
614    : Reader(Reader), F(F), KnownII(II) { }
615
616  static bool EqualKey(const internal_key_type& a,
617                       const internal_key_type& b) {
618    return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0
619                                  : false;
620  }
621
622  static unsigned ComputeHash(const internal_key_type& a) {
623    return llvm::HashString(StringRef(a.first, a.second));
624  }
625
626  // This hopefully will just get inlined and removed by the optimizer.
627  static const internal_key_type&
628  GetInternalKey(const external_key_type& x) { return x; }
629
630  // This hopefully will just get inlined and removed by the optimizer.
631  static const external_key_type&
632  GetExternalKey(const internal_key_type& x) { return x; }
633
634  static std::pair<unsigned, unsigned>
635  ReadKeyDataLength(const unsigned char*& d) {
636    using namespace clang::io;
637    unsigned DataLen = ReadUnalignedLE16(d);
638    unsigned KeyLen = ReadUnalignedLE16(d);
639    return std::make_pair(KeyLen, DataLen);
640  }
641
642  static std::pair<const char*, unsigned>
643  ReadKey(const unsigned char* d, unsigned n) {
644    assert(n >= 2 && d[n-1] == '\0');
645    return std::make_pair((const char*) d, n-1);
646  }
647
648  IdentifierInfo *ReadData(const internal_key_type& k,
649                           const unsigned char* d,
650                           unsigned DataLen) {
651    using namespace clang::io;
652    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(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(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      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  Module &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                                         Module &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(StringRef Msg) {
972  Error(diag::err_fe_pch_malformed, Msg);
973}
974
975void ASTReader::Error(unsigned DiagID,
976                      StringRef Arg1, 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(Module &F,
1000                               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(Module &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  Module *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->Kind != MK_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(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        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.createExpansionLoc(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(Module *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(Module &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  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(Module &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(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                                       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, Module &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 (ModuleReverseIterator I = ModuleMgr.rbegin(),
1744      E = ModuleMgr.rend(); I != E; ++I) {
1745    llvm::BitstreamCursor &MacroCursor = (*I)->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((*I)->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    Module &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(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.empty()) {
1862    // If no system root was given, default to '/'
1863    Filename.insert(Filename.begin(), '/');
1864    return;
1865  }
1866
1867  unsigned Length = isysroot.size();
1868  if (isysroot[Length - 1] != '/')
1869    Filename.insert(Filename.begin(), '/');
1870
1871  Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end());
1872}
1873
1874ASTReader::ASTReadResult
1875ASTReader::ReadASTBlock(Module &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      // FIXME: This could end up being a module.
2006      switch(ReadASTCore(StringRef(BlobStart, BlobLen), MK_PCH)) {
2007      case Failure: return Failure;
2008        // If we have to ignore the dependency, we'll have to ignore this too.
2009      case IgnorePCH: return IgnorePCH;
2010      case Success: break;
2011      }
2012      break;
2013    }
2014
2015    case TYPE_OFFSET:
2016      if (F.LocalNumTypes != 0) {
2017        Error("duplicate TYPE_OFFSET record in AST file");
2018        return Failure;
2019      }
2020      F.TypeOffsets = (const uint32_t *)BlobStart;
2021      F.LocalNumTypes = Record[0];
2022
2023      // Introduce the global -> local mapping for types within this
2024      // AST file.
2025      GlobalTypeMap.insert(std::make_pair(getTotalNumTypes() + 1,
2026                                          std::make_pair(&F,
2027                                                         -getTotalNumTypes())));
2028      TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2029      break;
2030
2031    case DECL_OFFSET:
2032      if (F.LocalNumDecls != 0) {
2033        Error("duplicate DECL_OFFSET record in AST file");
2034        return Failure;
2035      }
2036      F.DeclOffsets = (const uint32_t *)BlobStart;
2037      F.LocalNumDecls = Record[0];
2038
2039      // Introduce the global -> local mapping for declarations within this
2040      // AST file.
2041      GlobalDeclMap.insert(std::make_pair(getTotalNumDecls() + 1,
2042                                          std::make_pair(&F,
2043                                                         -getTotalNumDecls())));
2044      DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2045      break;
2046
2047    case TU_UPDATE_LEXICAL: {
2048      DeclContextInfo Info = {
2049        &F,
2050        /* No visible information */ 0,
2051        reinterpret_cast<const KindDeclIDPair *>(BlobStart),
2052        BlobLen / sizeof(KindDeclIDPair)
2053      };
2054      DeclContextOffsets[Context ? Context->getTranslationUnitDecl() : 0]
2055        .push_back(Info);
2056      break;
2057    }
2058
2059    case UPDATE_VISIBLE: {
2060      serialization::DeclID ID = Record[0];
2061      void *Table = ASTDeclContextNameLookupTable::Create(
2062                        (const unsigned char *)BlobStart + Record[1],
2063                        (const unsigned char *)BlobStart,
2064                        ASTDeclContextNameLookupTrait(*this, F));
2065      if (ID == 1 && Context) { // Is it the TU?
2066        DeclContextInfo Info = {
2067          &F, Table, /* No lexical inforamtion */ 0, 0
2068        };
2069        DeclContextOffsets[Context->getTranslationUnitDecl()].push_back(Info);
2070      } else
2071        PendingVisibleUpdates[ID].push_back(Table);
2072      break;
2073    }
2074
2075    case REDECLS_UPDATE_LATEST: {
2076      assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs");
2077      for (unsigned i = 0, e = Record.size(); i < e; i += 2) {
2078        DeclID First = Record[i], Latest = Record[i+1];
2079        assert((FirstLatestDeclIDs.find(First) == FirstLatestDeclIDs.end() ||
2080                Latest > FirstLatestDeclIDs[First]) &&
2081               "The new latest is supposed to come after the previous latest");
2082        FirstLatestDeclIDs[First] = Latest;
2083      }
2084      break;
2085    }
2086
2087    case LANGUAGE_OPTIONS:
2088      if (ParseLanguageOptions(Record) && !DisableValidation)
2089        return IgnorePCH;
2090      break;
2091
2092    case IDENTIFIER_TABLE:
2093      F.IdentifierTableData = BlobStart;
2094      if (Record[0]) {
2095        F.IdentifierLookupTable
2096          = ASTIdentifierLookupTable::Create(
2097                       (const unsigned char *)F.IdentifierTableData + Record[0],
2098                       (const unsigned char *)F.IdentifierTableData,
2099                       ASTIdentifierLookupTrait(*this, F));
2100        if (PP) {
2101          PP->getIdentifierTable().setExternalIdentifierLookup(this);
2102          PP->getHeaderSearchInfo().SetExternalLookup(this);
2103        }
2104      }
2105      break;
2106
2107    case IDENTIFIER_OFFSET:
2108      if (F.LocalNumIdentifiers != 0) {
2109        Error("duplicate IDENTIFIER_OFFSET record in AST file");
2110        return Failure;
2111      }
2112      F.IdentifierOffsets = (const uint32_t *)BlobStart;
2113      F.LocalNumIdentifiers = Record[0];
2114
2115      // Introduce the global -> local mapping for identifiers within this AST
2116      // file
2117      GlobalIdentifierMap.insert(
2118                     std::make_pair(getTotalNumIdentifiers() + 1,
2119                                    std::make_pair(&F,
2120                                                   -getTotalNumIdentifiers())));
2121      IdentifiersLoaded.resize(IdentifiersLoaded.size() +F.LocalNumIdentifiers);
2122      break;
2123
2124    case EXTERNAL_DEFINITIONS:
2125      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2126        ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I]));
2127      break;
2128
2129    case SPECIAL_TYPES:
2130      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2131        SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2132      break;
2133
2134    case STATISTICS:
2135      TotalNumStatements += Record[0];
2136      TotalNumMacros += Record[1];
2137      TotalLexicalDeclContexts += Record[2];
2138      TotalVisibleDeclContexts += Record[3];
2139      break;
2140
2141    case UNUSED_FILESCOPED_DECLS:
2142      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2143        UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2144      break;
2145
2146    case DELEGATING_CTORS:
2147      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2148        DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2149      break;
2150
2151    case WEAK_UNDECLARED_IDENTIFIERS:
2152      // Later blocks overwrite earlier ones.
2153      WeakUndeclaredIdentifiers.swap(Record);
2154      break;
2155
2156    case LOCALLY_SCOPED_EXTERNAL_DECLS:
2157      for (unsigned I = 0, N = Record.size(); I != N; ++I)
2158        LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I]));
2159      break;
2160
2161    case SELECTOR_OFFSETS:
2162      F.SelectorOffsets = (const uint32_t *)BlobStart;
2163      F.LocalNumSelectors = Record[0];
2164
2165      // Introduce the global -> local mapping for identifiers within this AST
2166      // file
2167      GlobalSelectorMap.insert(
2168                     std::make_pair(getTotalNumSelectors() + 1,
2169                                    std::make_pair(&F,
2170                                                   -getTotalNumSelectors())));
2171      SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2172      break;
2173
2174    case METHOD_POOL:
2175      F.SelectorLookupTableData = (const unsigned char *)BlobStart;
2176      if (Record[0])
2177        F.SelectorLookupTable
2178          = ASTSelectorLookupTable::Create(
2179                        F.SelectorLookupTableData + Record[0],
2180                        F.SelectorLookupTableData,
2181                        ASTSelectorLookupTrait(*this, F));
2182      TotalNumMethodPoolEntries += Record[1];
2183      break;
2184
2185    case REFERENCED_SELECTOR_POOL:
2186      F.ReferencedSelectorsData.swap(Record);
2187      break;
2188
2189    case PP_COUNTER_VALUE:
2190      if (!Record.empty() && Listener)
2191        Listener->ReadCounter(Record[0]);
2192      break;
2193
2194    case SOURCE_LOCATION_OFFSETS: {
2195      F.SLocEntryOffsets = (const uint32_t *)BlobStart;
2196      F.LocalNumSLocEntries = Record[0];
2197      llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2198          SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, Record[1]);
2199      // Make our entry in the range map. BaseID is negative and growing, so
2200      // we invert it. Because we invert it, though, we need the other end of
2201      // the range.
2202      unsigned RangeStart =
2203          unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2204      GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2205      F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2206
2207      // Initialize the remapping table.
2208      // Invalid stays invalid.
2209      F.SLocRemap.insert(std::make_pair(0U, 0));
2210      // This module. Base was 2 when being compiled.
2211      F.SLocRemap.insert(std::make_pair(2U,
2212                                  static_cast<int>(F.SLocEntryBaseOffset - 2)));
2213
2214      TotalNumSLocEntries += F.LocalNumSLocEntries;
2215      break;
2216    }
2217
2218    case SOURCE_LOCATION_MAP: {
2219      // Additional remapping information.
2220      const unsigned char *Data = (const unsigned char*)BlobStart;
2221      const unsigned char *DataEnd = Data + BlobLen;
2222      while(Data < DataEnd) {
2223        uint32_t Offset = io::ReadUnalignedLE32(Data);
2224        uint16_t Len = io::ReadUnalignedLE16(Data);
2225        StringRef Name = StringRef((const char*)Data, Len);
2226        Module *OM = ModuleMgr.lookup(Name);
2227        if (!OM) {
2228          Error("SourceLocation remap refers to unknown module");
2229          return Failure;
2230        }
2231        // My Offset is mapped to OM->SLocEntryBaseOffset.
2232        F.SLocRemap.insert(std::make_pair(Offset,
2233                        static_cast<int>(OM->SLocEntryBaseOffset - Offset)));
2234        Data += Len;
2235      }
2236      break;
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      StringRef ASTBranch(BlobStart, BlobLen);
2322      if (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 (ModuleIterator I = ModuleMgr.begin(),
2468      E = ModuleMgr.end(); I != E; ++I) {
2469    Module *F = *I;
2470    llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
2471
2472    for (unsigned i = 0, e = F->LocalNumSLocFileEntries; i != e; ++i) {
2473      SLocEntryCursor.JumpToBit(F->SLocFileOffsets[i]);
2474      unsigned Code = SLocEntryCursor.ReadCode();
2475      if (Code == llvm::bitc::END_BLOCK ||
2476          Code == llvm::bitc::ENTER_SUBBLOCK ||
2477          Code == llvm::bitc::DEFINE_ABBREV) {
2478        Error("incorrectly-formatted source location entry in AST file");
2479        return Failure;
2480      }
2481
2482      RecordData Record;
2483      const char *BlobStart;
2484      unsigned BlobLen;
2485      switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) {
2486      default:
2487        Error("incorrectly-formatted source location entry in AST file");
2488        return Failure;
2489
2490      case SM_SLOC_FILE_ENTRY: {
2491        StringRef Filename(BlobStart, BlobLen);
2492        const FileEntry *File = getFileEntry(Filename);
2493
2494        if (File == 0) {
2495          std::string ErrorStr = "could not find file '";
2496          ErrorStr += Filename;
2497          ErrorStr += "' referenced by AST file";
2498          Error(ErrorStr.c_str());
2499          return IgnorePCH;
2500        }
2501
2502        if (Record.size() < 6) {
2503          Error("source location entry is incorrect");
2504          return Failure;
2505        }
2506
2507        // The stat info from the FileEntry came from the cached stat
2508        // info of the PCH, so we cannot trust it.
2509        struct stat StatBuf;
2510        if (::stat(File->getName(), &StatBuf) != 0) {
2511          StatBuf.st_size = File->getSize();
2512          StatBuf.st_mtime = File->getModificationTime();
2513        }
2514
2515        if (((off_t)Record[4] != StatBuf.st_size
2516#if !defined(LLVM_ON_WIN32)
2517            // In our regression testing, the Windows file system seems to
2518            // have inconsistent modification times that sometimes
2519            // erroneously trigger this error-handling path.
2520             || (time_t)Record[5] != StatBuf.st_mtime
2521#endif
2522            )) {
2523          Error(diag::err_fe_pch_file_modified, Filename);
2524          return IgnorePCH;
2525        }
2526
2527        break;
2528      }
2529      }
2530    }
2531  }
2532
2533  return Success;
2534}
2535
2536ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
2537                                            ModuleKind Type) {
2538  switch(ReadASTCore(FileName, Type)) {
2539  case Failure: return Failure;
2540  case IgnorePCH: return IgnorePCH;
2541  case Success: break;
2542  }
2543
2544  // Here comes stuff that we only do once the entire chain is loaded.
2545
2546  if (!DisableValidation) {
2547    switch(validateFileEntries()) {
2548    case Failure: return Failure;
2549    case IgnorePCH: return IgnorePCH;
2550    case Success: break;
2551    }
2552  }
2553
2554  // Preload SLocEntries.
2555  for (unsigned I = 0, N = PreloadSLocEntries.size(); I != N; ++I) {
2556    ASTReadResult Result = ReadSLocEntryRecord(PreloadSLocEntries[I]);
2557    if (Result != Success)
2558      return Failure;
2559  }
2560  PreloadSLocEntries.clear();
2561
2562  // Check the predefines buffers.
2563  if (!DisableValidation && CheckPredefinesBuffers())
2564    return IgnorePCH;
2565
2566  if (PP) {
2567    // Initialization of keywords and pragmas occurs before the
2568    // AST file is read, so there may be some identifiers that were
2569    // loaded into the IdentifierTable before we intercepted the
2570    // creation of identifiers. Iterate through the list of known
2571    // identifiers and determine whether we have to establish
2572    // preprocessor definitions or top-level identifier declaration
2573    // chains for those identifiers.
2574    //
2575    // We copy the IdentifierInfo pointers to a small vector first,
2576    // since de-serializing declarations or macro definitions can add
2577    // new entries into the identifier table, invalidating the
2578    // iterators.
2579    SmallVector<IdentifierInfo *, 128> Identifiers;
2580    for (IdentifierTable::iterator Id = PP->getIdentifierTable().begin(),
2581                                IdEnd = PP->getIdentifierTable().end();
2582         Id != IdEnd; ++Id)
2583      Identifiers.push_back(Id->second);
2584    // We need to search the tables in all files.
2585    for (ModuleIterator J = ModuleMgr.begin(),
2586        M = ModuleMgr.end(); J != M; ++J) {
2587      ASTIdentifierLookupTable *IdTable
2588        = (ASTIdentifierLookupTable *)(*J)->IdentifierLookupTable;
2589      // Not all AST files necessarily have identifier tables, only the useful
2590      // ones.
2591      if (!IdTable)
2592        continue;
2593      for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) {
2594        IdentifierInfo *II = Identifiers[I];
2595        // Look in the on-disk hash tables for an entry for this identifier
2596        ASTIdentifierLookupTrait Info(*this, *(*J), II);
2597        std::pair<const char*,unsigned> Key(II->getNameStart(),II->getLength());
2598        ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info);
2599        if (Pos == IdTable->end())
2600          continue;
2601
2602        // Dereferencing the iterator has the effect of populating the
2603        // IdentifierInfo node with the various declarations it needs.
2604        (void)*Pos;
2605      }
2606    }
2607  }
2608
2609  if (Context)
2610    InitializeContext(*Context);
2611
2612  if (DeserializationListener)
2613    DeserializationListener->ReaderInitialized(this);
2614
2615  // If this AST file is a precompiled preamble, then set the main file ID of
2616  // the source manager to the file source file from which the preamble was
2617  // built. This is the only valid way to use a precompiled preamble.
2618  if (Type == MK_Preamble) {
2619    if (OriginalFileID.isInvalid()) {
2620      SourceLocation Loc
2621        = SourceMgr.getLocation(FileMgr.getFile(getOriginalSourceFile()), 1, 1);
2622      if (Loc.isValid())
2623        OriginalFileID = SourceMgr.getDecomposedLoc(Loc).first;
2624    }
2625    else {
2626      OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID
2627                                        + OriginalFileID.getOpaqueValue() - 1);
2628    }
2629
2630    if (!OriginalFileID.isInvalid())
2631      SourceMgr.SetPreambleFileID(OriginalFileID);
2632  }
2633
2634  return Success;
2635}
2636
2637ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName,
2638                                                ModuleKind Type) {
2639  Module &F = ModuleMgr.addModule(FileName, Type);
2640
2641  if (FileName != "-") {
2642    CurrentDir = llvm::sys::path::parent_path(FileName);
2643    if (CurrentDir.empty()) CurrentDir = ".";
2644  }
2645
2646  if (!ASTBuffers.empty()) {
2647    F.Buffer.reset(ASTBuffers.back());
2648    ASTBuffers.pop_back();
2649    assert(F.Buffer && "Passed null buffer");
2650  } else {
2651    // Open the AST file.
2652    //
2653    // FIXME: This shouldn't be here, we should just take a raw_ostream.
2654    std::string ErrStr;
2655    llvm::error_code ec;
2656    if (FileName == "-") {
2657      ec = llvm::MemoryBuffer::getSTDIN(F.Buffer);
2658      if (ec)
2659        ErrStr = ec.message();
2660    } else
2661      F.Buffer.reset(FileMgr.getBufferForFile(FileName, &ErrStr));
2662    if (!F.Buffer) {
2663      Error(ErrStr.c_str());
2664      return IgnorePCH;
2665    }
2666  }
2667
2668  // Initialize the stream
2669  F.StreamFile.init((const unsigned char *)F.Buffer->getBufferStart(),
2670                    (const unsigned char *)F.Buffer->getBufferEnd());
2671  llvm::BitstreamCursor &Stream = F.Stream;
2672  Stream.init(F.StreamFile);
2673  F.SizeInBits = F.Buffer->getBufferSize() * 8;
2674
2675  // Sniff for the signature.
2676  if (Stream.Read(8) != 'C' ||
2677      Stream.Read(8) != 'P' ||
2678      Stream.Read(8) != 'C' ||
2679      Stream.Read(8) != 'H') {
2680    Diag(diag::err_not_a_pch_file) << FileName;
2681    return Failure;
2682  }
2683
2684  while (!Stream.AtEndOfStream()) {
2685    unsigned Code = Stream.ReadCode();
2686
2687    if (Code != llvm::bitc::ENTER_SUBBLOCK) {
2688      Error("invalid record at top-level of AST file");
2689      return Failure;
2690    }
2691
2692    unsigned BlockID = Stream.ReadSubBlockID();
2693
2694    // We only know the AST subblock ID.
2695    switch (BlockID) {
2696    case llvm::bitc::BLOCKINFO_BLOCK_ID:
2697      if (Stream.ReadBlockInfoBlock()) {
2698        Error("malformed BlockInfoBlock in AST file");
2699        return Failure;
2700      }
2701      break;
2702    case AST_BLOCK_ID:
2703      switch (ReadASTBlock(F)) {
2704      case Success:
2705        break;
2706
2707      case Failure:
2708        return Failure;
2709
2710      case IgnorePCH:
2711        // FIXME: We could consider reading through to the end of this
2712        // AST block, skipping subblocks, to see if there are other
2713        // AST blocks elsewhere.
2714
2715        // FIXME: We can't clear loaded slocentries anymore.
2716        //SourceMgr.ClearPreallocatedSLocEntries();
2717
2718        // Remove the stat cache.
2719        if (F.StatCache)
2720          FileMgr.removeStatCache((ASTStatCache*)F.StatCache);
2721
2722        return IgnorePCH;
2723      }
2724      break;
2725    default:
2726      if (Stream.SkipBlock()) {
2727        Error("malformed block record in AST file");
2728        return Failure;
2729      }
2730      break;
2731    }
2732  }
2733
2734  // Once read, set the Module bit base offset and update the size in
2735  // bits of all files we've seen.
2736  F.GlobalBitOffset = TotalModulesSizeInBits;
2737  TotalModulesSizeInBits += F.SizeInBits;
2738  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
2739  return Success;
2740}
2741
2742void ASTReader::setPreprocessor(Preprocessor &pp) {
2743  PP = &pp;
2744
2745  if (unsigned N = getTotalNumPreprocessedEntities()) {
2746    if (!PP->getPreprocessingRecord())
2747      PP->createPreprocessingRecord(true);
2748    PP->getPreprocessingRecord()->SetExternalSource(*this);
2749    PP->getPreprocessingRecord()->allocateLoadedEntities(N);
2750  }
2751
2752  PP->getHeaderSearchInfo().SetExternalLookup(this);
2753  PP->getHeaderSearchInfo().SetExternalSource(this);
2754}
2755
2756void ASTReader::InitializeContext(ASTContext &Ctx) {
2757  Context = &Ctx;
2758  assert(Context && "Passed null context!");
2759
2760  assert(PP && "Forgot to set Preprocessor ?");
2761  PP->getIdentifierTable().setExternalIdentifierLookup(this);
2762  PP->setExternalSource(this);
2763
2764  // If we have an update block for the TU waiting, we have to add it before
2765  // deserializing the decl.
2766  DeclContextOffsetsMap::iterator DCU = DeclContextOffsets.find(0);
2767  if (DCU != DeclContextOffsets.end()) {
2768    // Insertion could invalidate map, so grab vector.
2769    DeclContextInfos T;
2770    T.swap(DCU->second);
2771    DeclContextOffsets.erase(DCU);
2772    DeclContextOffsets[Ctx.getTranslationUnitDecl()].swap(T);
2773  }
2774
2775  // Load the translation unit declaration
2776  GetTranslationUnitDecl();
2777
2778  // Load the special types.
2779  Context->setBuiltinVaListType(
2780    GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST]));
2781  if (unsigned Id = SpecialTypes[SPECIAL_TYPE_OBJC_ID])
2782    Context->setObjCIdType(GetType(Id));
2783  if (unsigned Sel = SpecialTypes[SPECIAL_TYPE_OBJC_SELECTOR])
2784    Context->setObjCSelType(GetType(Sel));
2785  if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL])
2786    Context->setObjCProtoType(GetType(Proto));
2787  if (unsigned Class = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS])
2788    Context->setObjCClassType(GetType(Class));
2789
2790  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING])
2791    Context->setCFConstantStringType(GetType(String));
2792  if (unsigned FastEnum
2793        = SpecialTypes[SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE])
2794    Context->setObjCFastEnumerationStateType(GetType(FastEnum));
2795  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
2796    QualType FileType = GetType(File);
2797    if (FileType.isNull()) {
2798      Error("FILE type is NULL");
2799      return;
2800    }
2801    if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
2802      Context->setFILEDecl(Typedef->getDecl());
2803    else {
2804      const TagType *Tag = FileType->getAs<TagType>();
2805      if (!Tag) {
2806        Error("Invalid FILE type in AST file");
2807        return;
2808      }
2809      Context->setFILEDecl(Tag->getDecl());
2810    }
2811  }
2812  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) {
2813    QualType Jmp_bufType = GetType(Jmp_buf);
2814    if (Jmp_bufType.isNull()) {
2815      Error("jmp_bug type is NULL");
2816      return;
2817    }
2818    if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
2819      Context->setjmp_bufDecl(Typedef->getDecl());
2820    else {
2821      const TagType *Tag = Jmp_bufType->getAs<TagType>();
2822      if (!Tag) {
2823        Error("Invalid jmp_buf type in AST file");
2824        return;
2825      }
2826      Context->setjmp_bufDecl(Tag->getDecl());
2827    }
2828  }
2829  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) {
2830    QualType Sigjmp_bufType = GetType(Sigjmp_buf);
2831    if (Sigjmp_bufType.isNull()) {
2832      Error("sigjmp_buf type is NULL");
2833      return;
2834    }
2835    if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
2836      Context->setsigjmp_bufDecl(Typedef->getDecl());
2837    else {
2838      const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
2839      assert(Tag && "Invalid sigjmp_buf type in AST file");
2840      Context->setsigjmp_bufDecl(Tag->getDecl());
2841    }
2842  }
2843  if (unsigned ObjCIdRedef
2844        = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION])
2845    Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef);
2846  if (unsigned ObjCClassRedef
2847      = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION])
2848    Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef);
2849  if (unsigned String = SpecialTypes[SPECIAL_TYPE_BLOCK_DESCRIPTOR])
2850    Context->setBlockDescriptorType(GetType(String));
2851  if (unsigned String
2852      = SpecialTypes[SPECIAL_TYPE_BLOCK_EXTENDED_DESCRIPTOR])
2853    Context->setBlockDescriptorExtendedType(GetType(String));
2854  if (unsigned ObjCSelRedef
2855      = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION])
2856    Context->ObjCSelRedefinitionType = GetType(ObjCSelRedef);
2857  if (unsigned String = SpecialTypes[SPECIAL_TYPE_NS_CONSTANT_STRING])
2858    Context->setNSConstantStringType(GetType(String));
2859
2860  if (SpecialTypes[SPECIAL_TYPE_INT128_INSTALLED])
2861    Context->setInt128Installed();
2862
2863  if (unsigned AutoDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_DEDUCT])
2864    Context->AutoDeductTy = GetType(AutoDeduct);
2865  if (unsigned AutoRRefDeduct = SpecialTypes[SPECIAL_TYPE_AUTO_RREF_DEDUCT])
2866    Context->AutoRRefDeductTy = GetType(AutoRRefDeduct);
2867
2868  ReadPragmaDiagnosticMappings(Context->getDiagnostics());
2869
2870  // If there were any CUDA special declarations, deserialize them.
2871  if (!CUDASpecialDeclRefs.empty()) {
2872    assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
2873    Context->setcudaConfigureCallDecl(
2874                           cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
2875  }
2876}
2877
2878/// \brief Retrieve the name of the original source file name
2879/// directly from the AST file, without actually loading the AST
2880/// file.
2881std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
2882                                             FileManager &FileMgr,
2883                                             Diagnostic &Diags) {
2884  // Open the AST file.
2885  std::string ErrStr;
2886  llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
2887  Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr));
2888  if (!Buffer) {
2889    Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr;
2890    return std::string();
2891  }
2892
2893  // Initialize the stream
2894  llvm::BitstreamReader StreamFile;
2895  llvm::BitstreamCursor Stream;
2896  StreamFile.init((const unsigned char *)Buffer->getBufferStart(),
2897                  (const unsigned char *)Buffer->getBufferEnd());
2898  Stream.init(StreamFile);
2899
2900  // Sniff for the signature.
2901  if (Stream.Read(8) != 'C' ||
2902      Stream.Read(8) != 'P' ||
2903      Stream.Read(8) != 'C' ||
2904      Stream.Read(8) != 'H') {
2905    Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
2906    return std::string();
2907  }
2908
2909  RecordData Record;
2910  while (!Stream.AtEndOfStream()) {
2911    unsigned Code = Stream.ReadCode();
2912
2913    if (Code == llvm::bitc::ENTER_SUBBLOCK) {
2914      unsigned BlockID = Stream.ReadSubBlockID();
2915
2916      // We only know the AST subblock ID.
2917      switch (BlockID) {
2918      case AST_BLOCK_ID:
2919        if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2920          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2921          return std::string();
2922        }
2923        break;
2924
2925      default:
2926        if (Stream.SkipBlock()) {
2927          Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
2928          return std::string();
2929        }
2930        break;
2931      }
2932      continue;
2933    }
2934
2935    if (Code == llvm::bitc::END_BLOCK) {
2936      if (Stream.ReadBlockEnd()) {
2937        Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName;
2938        return std::string();
2939      }
2940      continue;
2941    }
2942
2943    if (Code == llvm::bitc::DEFINE_ABBREV) {
2944      Stream.ReadAbbrevRecord();
2945      continue;
2946    }
2947
2948    Record.clear();
2949    const char *BlobStart = 0;
2950    unsigned BlobLen = 0;
2951    if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)
2952          == ORIGINAL_FILE_NAME)
2953      return std::string(BlobStart, BlobLen);
2954  }
2955
2956  return std::string();
2957}
2958
2959/// \brief Parse the record that corresponds to a LangOptions data
2960/// structure.
2961///
2962/// This routine parses the language options from the AST file and then gives
2963/// them to the AST listener if one is set.
2964///
2965/// \returns true if the listener deems the file unacceptable, false otherwise.
2966bool ASTReader::ParseLanguageOptions(
2967                             const SmallVectorImpl<uint64_t> &Record) {
2968  if (Listener) {
2969    LangOptions LangOpts;
2970
2971  #define PARSE_LANGOPT(Option)                  \
2972      LangOpts.Option = Record[Idx];             \
2973      ++Idx
2974
2975    unsigned Idx = 0;
2976    PARSE_LANGOPT(Trigraphs);
2977    PARSE_LANGOPT(BCPLComment);
2978    PARSE_LANGOPT(DollarIdents);
2979    PARSE_LANGOPT(AsmPreprocessor);
2980    PARSE_LANGOPT(GNUMode);
2981    PARSE_LANGOPT(GNUKeywords);
2982    PARSE_LANGOPT(ImplicitInt);
2983    PARSE_LANGOPT(Digraphs);
2984    PARSE_LANGOPT(HexFloats);
2985    PARSE_LANGOPT(C99);
2986    PARSE_LANGOPT(C1X);
2987    PARSE_LANGOPT(Microsoft);
2988    PARSE_LANGOPT(CPlusPlus);
2989    PARSE_LANGOPT(CPlusPlus0x);
2990    PARSE_LANGOPT(CXXOperatorNames);
2991    PARSE_LANGOPT(ObjC1);
2992    PARSE_LANGOPT(ObjC2);
2993    PARSE_LANGOPT(ObjCNonFragileABI);
2994    PARSE_LANGOPT(ObjCNonFragileABI2);
2995    PARSE_LANGOPT(AppleKext);
2996    PARSE_LANGOPT(ObjCDefaultSynthProperties);
2997    PARSE_LANGOPT(ObjCInferRelatedResultType);
2998    PARSE_LANGOPT(NoConstantCFStrings);
2999    PARSE_LANGOPT(PascalStrings);
3000    PARSE_LANGOPT(WritableStrings);
3001    PARSE_LANGOPT(LaxVectorConversions);
3002    PARSE_LANGOPT(AltiVec);
3003    PARSE_LANGOPT(Exceptions);
3004    PARSE_LANGOPT(ObjCExceptions);
3005    PARSE_LANGOPT(CXXExceptions);
3006    PARSE_LANGOPT(SjLjExceptions);
3007    PARSE_LANGOPT(MSBitfields);
3008    PARSE_LANGOPT(NeXTRuntime);
3009    PARSE_LANGOPT(Freestanding);
3010    PARSE_LANGOPT(NoBuiltin);
3011    PARSE_LANGOPT(ThreadsafeStatics);
3012    PARSE_LANGOPT(POSIXThreads);
3013    PARSE_LANGOPT(Blocks);
3014    PARSE_LANGOPT(EmitAllDecls);
3015    PARSE_LANGOPT(MathErrno);
3016    LangOpts.setSignedOverflowBehavior((LangOptions::SignedOverflowBehaviorTy)
3017                                       Record[Idx++]);
3018    PARSE_LANGOPT(HeinousExtensions);
3019    PARSE_LANGOPT(Optimize);
3020    PARSE_LANGOPT(OptimizeSize);
3021    PARSE_LANGOPT(Static);
3022    PARSE_LANGOPT(PICLevel);
3023    PARSE_LANGOPT(GNUInline);
3024    PARSE_LANGOPT(NoInline);
3025    PARSE_LANGOPT(Deprecated);
3026    PARSE_LANGOPT(AccessControl);
3027    PARSE_LANGOPT(CharIsSigned);
3028    PARSE_LANGOPT(ShortWChar);
3029    PARSE_LANGOPT(ShortEnums);
3030    LangOpts.setGCMode((LangOptions::GCMode)Record[Idx++]);
3031    LangOpts.setVisibilityMode((Visibility)Record[Idx++]);
3032    LangOpts.setStackProtectorMode((LangOptions::StackProtectorMode)
3033                                   Record[Idx++]);
3034    PARSE_LANGOPT(InstantiationDepth);
3035    PARSE_LANGOPT(OpenCL);
3036    PARSE_LANGOPT(CUDA);
3037    PARSE_LANGOPT(CatchUndefined);
3038    PARSE_LANGOPT(DefaultFPContract);
3039    PARSE_LANGOPT(ElideConstructors);
3040    PARSE_LANGOPT(SpellChecking);
3041    PARSE_LANGOPT(MRTD);
3042    PARSE_LANGOPT(ObjCAutoRefCount);
3043  #undef PARSE_LANGOPT
3044
3045    return Listener->ReadLanguageOptions(LangOpts);
3046  }
3047
3048  return false;
3049}
3050
3051void ASTReader::ReadPreprocessedEntities() {
3052  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3053    Module &F = *(*I);
3054    if (!F.PreprocessorDetailCursor.getBitStreamReader())
3055      continue;
3056
3057    SavedStreamPosition SavedPosition(F.PreprocessorDetailCursor);
3058    F.PreprocessorDetailCursor.JumpToBit(F.PreprocessorDetailStartOffset);
3059    while (LoadPreprocessedEntity(F)) { }
3060  }
3061}
3062
3063PreprocessedEntity *ASTReader::ReadPreprocessedEntityAtOffset(uint64_t Offset) {
3064  RecordLocation Loc = getLocalBitOffset(Offset);
3065
3066  // Keep track of where we are in the stream, then jump back there
3067  // after reading this entity.
3068  SavedStreamPosition SavedPosition(Loc.F->PreprocessorDetailCursor);
3069  Loc.F->PreprocessorDetailCursor.JumpToBit(Loc.Offset);
3070  return LoadPreprocessedEntity(*Loc.F);
3071}
3072
3073HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
3074  HeaderFileInfoTrait Trait(FE->getName());
3075  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3076    Module &F = *(*I);
3077    HeaderFileInfoLookupTable *Table
3078      = static_cast<HeaderFileInfoLookupTable *>(F.HeaderFileInfoTable);
3079    if (!Table)
3080      continue;
3081
3082    // Look in the on-disk hash table for an entry for this file name.
3083    HeaderFileInfoLookupTable::iterator Pos = Table->find(FE->getName(),
3084                                                          &Trait);
3085    if (Pos == Table->end())
3086      continue;
3087
3088    HeaderFileInfo HFI = *Pos;
3089    if (Listener)
3090      Listener->ReadHeaderFileInfo(HFI, FE->getUID());
3091
3092    return HFI;
3093  }
3094
3095  return HeaderFileInfo();
3096}
3097
3098void ASTReader::ReadPragmaDiagnosticMappings(Diagnostic &Diag) {
3099  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
3100    Module &F = *(*I);
3101    unsigned Idx = 0;
3102    while (Idx < F.PragmaDiagMappings.size()) {
3103      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
3104      while (1) {
3105        assert(Idx < F.PragmaDiagMappings.size() &&
3106               "Invalid data, didn't find '-1' marking end of diag/map pairs");
3107        if (Idx >= F.PragmaDiagMappings.size()) {
3108          break; // Something is messed up but at least avoid infinite loop in
3109                 // release build.
3110        }
3111        unsigned DiagID = F.PragmaDiagMappings[Idx++];
3112        if (DiagID == (unsigned)-1) {
3113          break; // no more diag/map pairs for this location.
3114        }
3115        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
3116        Diag.setDiagnosticMapping(DiagID, Map, Loc);
3117      }
3118    }
3119  }
3120}
3121
3122/// \brief Get the correct cursor and offset for loading a type.
3123ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
3124  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index+1);
3125  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
3126  return RecordLocation(I->second.first,
3127      I->second.first->TypeOffsets[Index + I->second.second]);
3128}
3129
3130/// \brief Read and return the type with the given index..
3131///
3132/// The index is the type ID, shifted and minus the number of predefs. This
3133/// routine actually reads the record corresponding to the type at the given
3134/// location. It is a helper routine for GetType, which deals with reading type
3135/// IDs.
3136QualType ASTReader::readTypeRecord(unsigned Index) {
3137  RecordLocation Loc = TypeCursorForIndex(Index);
3138  llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
3139
3140  // Keep track of where we are in the stream, then jump back there
3141  // after reading this type.
3142  SavedStreamPosition SavedPosition(DeclsCursor);
3143
3144  ReadingKindTracker ReadingKind(Read_Type, *this);
3145
3146  // Note that we are loading a type record.
3147  Deserializing AType(this);
3148
3149  unsigned Idx = 0;
3150  DeclsCursor.JumpToBit(Loc.Offset);
3151  RecordData Record;
3152  unsigned Code = DeclsCursor.ReadCode();
3153  switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) {
3154  case TYPE_EXT_QUAL: {
3155    if (Record.size() != 2) {
3156      Error("Incorrect encoding of extended qualifier type");
3157      return QualType();
3158    }
3159    QualType Base = readType(*Loc.F, Record, Idx);
3160    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
3161    return Context->getQualifiedType(Base, Quals);
3162  }
3163
3164  case TYPE_COMPLEX: {
3165    if (Record.size() != 1) {
3166      Error("Incorrect encoding of complex type");
3167      return QualType();
3168    }
3169    QualType ElemType = readType(*Loc.F, Record, Idx);
3170    return Context->getComplexType(ElemType);
3171  }
3172
3173  case TYPE_POINTER: {
3174    if (Record.size() != 1) {
3175      Error("Incorrect encoding of pointer type");
3176      return QualType();
3177    }
3178    QualType PointeeType = readType(*Loc.F, Record, Idx);
3179    return Context->getPointerType(PointeeType);
3180  }
3181
3182  case TYPE_BLOCK_POINTER: {
3183    if (Record.size() != 1) {
3184      Error("Incorrect encoding of block pointer type");
3185      return QualType();
3186    }
3187    QualType PointeeType = readType(*Loc.F, Record, Idx);
3188    return Context->getBlockPointerType(PointeeType);
3189  }
3190
3191  case TYPE_LVALUE_REFERENCE: {
3192    if (Record.size() != 2) {
3193      Error("Incorrect encoding of lvalue reference type");
3194      return QualType();
3195    }
3196    QualType PointeeType = readType(*Loc.F, Record, Idx);
3197    return Context->getLValueReferenceType(PointeeType, Record[1]);
3198  }
3199
3200  case TYPE_RVALUE_REFERENCE: {
3201    if (Record.size() != 1) {
3202      Error("Incorrect encoding of rvalue reference type");
3203      return QualType();
3204    }
3205    QualType PointeeType = readType(*Loc.F, Record, Idx);
3206    return Context->getRValueReferenceType(PointeeType);
3207  }
3208
3209  case TYPE_MEMBER_POINTER: {
3210    if (Record.size() != 2) {
3211      Error("Incorrect encoding of member pointer type");
3212      return QualType();
3213    }
3214    QualType PointeeType = readType(*Loc.F, Record, Idx);
3215    QualType ClassType = readType(*Loc.F, Record, Idx);
3216    if (PointeeType.isNull() || ClassType.isNull())
3217      return QualType();
3218
3219    return Context->getMemberPointerType(PointeeType, ClassType.getTypePtr());
3220  }
3221
3222  case TYPE_CONSTANT_ARRAY: {
3223    QualType ElementType = readType(*Loc.F, Record, Idx);
3224    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3225    unsigned IndexTypeQuals = Record[2];
3226    unsigned Idx = 3;
3227    llvm::APInt Size = ReadAPInt(Record, Idx);
3228    return Context->getConstantArrayType(ElementType, Size,
3229                                         ASM, IndexTypeQuals);
3230  }
3231
3232  case TYPE_INCOMPLETE_ARRAY: {
3233    QualType ElementType = readType(*Loc.F, Record, Idx);
3234    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3235    unsigned IndexTypeQuals = Record[2];
3236    return Context->getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
3237  }
3238
3239  case TYPE_VARIABLE_ARRAY: {
3240    QualType ElementType = readType(*Loc.F, Record, Idx);
3241    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
3242    unsigned IndexTypeQuals = Record[2];
3243    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
3244    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
3245    return Context->getVariableArrayType(ElementType, ReadExpr(*Loc.F),
3246                                         ASM, IndexTypeQuals,
3247                                         SourceRange(LBLoc, RBLoc));
3248  }
3249
3250  case TYPE_VECTOR: {
3251    if (Record.size() != 3) {
3252      Error("incorrect encoding of vector type in AST file");
3253      return QualType();
3254    }
3255
3256    QualType ElementType = readType(*Loc.F, Record, Idx);
3257    unsigned NumElements = Record[1];
3258    unsigned VecKind = Record[2];
3259    return Context->getVectorType(ElementType, NumElements,
3260                                  (VectorType::VectorKind)VecKind);
3261  }
3262
3263  case TYPE_EXT_VECTOR: {
3264    if (Record.size() != 3) {
3265      Error("incorrect encoding of extended vector type in AST file");
3266      return QualType();
3267    }
3268
3269    QualType ElementType = readType(*Loc.F, Record, Idx);
3270    unsigned NumElements = Record[1];
3271    return Context->getExtVectorType(ElementType, NumElements);
3272  }
3273
3274  case TYPE_FUNCTION_NO_PROTO: {
3275    if (Record.size() != 6) {
3276      Error("incorrect encoding of no-proto function type");
3277      return QualType();
3278    }
3279    QualType ResultType = readType(*Loc.F, Record, Idx);
3280    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
3281                               (CallingConv)Record[4], Record[5]);
3282    return Context->getFunctionNoProtoType(ResultType, Info);
3283  }
3284
3285  case TYPE_FUNCTION_PROTO: {
3286    QualType ResultType = readType(*Loc.F, Record, Idx);
3287
3288    FunctionProtoType::ExtProtoInfo EPI;
3289    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
3290                                        /*hasregparm*/ Record[2],
3291                                        /*regparm*/ Record[3],
3292                                        static_cast<CallingConv>(Record[4]),
3293                                        /*produces*/ Record[5]);
3294
3295    unsigned Idx = 6;
3296    unsigned NumParams = Record[Idx++];
3297    SmallVector<QualType, 16> ParamTypes;
3298    for (unsigned I = 0; I != NumParams; ++I)
3299      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
3300
3301    EPI.Variadic = Record[Idx++];
3302    EPI.TypeQuals = Record[Idx++];
3303    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
3304    ExceptionSpecificationType EST =
3305        static_cast<ExceptionSpecificationType>(Record[Idx++]);
3306    EPI.ExceptionSpecType = EST;
3307    if (EST == EST_Dynamic) {
3308      EPI.NumExceptions = Record[Idx++];
3309      SmallVector<QualType, 2> Exceptions;
3310      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
3311        Exceptions.push_back(readType(*Loc.F, Record, Idx));
3312      EPI.Exceptions = Exceptions.data();
3313    } else if (EST == EST_ComputedNoexcept) {
3314      EPI.NoexceptExpr = ReadExpr(*Loc.F);
3315    }
3316    return Context->getFunctionType(ResultType, ParamTypes.data(), NumParams,
3317                                    EPI);
3318  }
3319
3320  case TYPE_UNRESOLVED_USING: {
3321    unsigned Idx = 0;
3322    return Context->getTypeDeclType(
3323                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
3324  }
3325
3326  case TYPE_TYPEDEF: {
3327    if (Record.size() != 2) {
3328      Error("incorrect encoding of typedef type");
3329      return QualType();
3330    }
3331    unsigned Idx = 0;
3332    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
3333    QualType Canonical = readType(*Loc.F, Record, Idx);
3334    if (!Canonical.isNull())
3335      Canonical = Context->getCanonicalType(Canonical);
3336    return Context->getTypedefType(Decl, Canonical);
3337  }
3338
3339  case TYPE_TYPEOF_EXPR:
3340    return Context->getTypeOfExprType(ReadExpr(*Loc.F));
3341
3342  case TYPE_TYPEOF: {
3343    if (Record.size() != 1) {
3344      Error("incorrect encoding of typeof(type) in AST file");
3345      return QualType();
3346    }
3347    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3348    return Context->getTypeOfType(UnderlyingType);
3349  }
3350
3351  case TYPE_DECLTYPE:
3352    return Context->getDecltypeType(ReadExpr(*Loc.F));
3353
3354  case TYPE_UNARY_TRANSFORM: {
3355    QualType BaseType = readType(*Loc.F, Record, Idx);
3356    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
3357    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
3358    return Context->getUnaryTransformType(BaseType, UnderlyingType, UKind);
3359  }
3360
3361  case TYPE_AUTO:
3362    return Context->getAutoType(readType(*Loc.F, Record, Idx));
3363
3364  case TYPE_RECORD: {
3365    if (Record.size() != 2) {
3366      Error("incorrect encoding of record type");
3367      return QualType();
3368    }
3369    unsigned Idx = 0;
3370    bool IsDependent = Record[Idx++];
3371    QualType T
3372      = Context->getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx));
3373    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3374    return T;
3375  }
3376
3377  case TYPE_ENUM: {
3378    if (Record.size() != 2) {
3379      Error("incorrect encoding of enum type");
3380      return QualType();
3381    }
3382    unsigned Idx = 0;
3383    bool IsDependent = Record[Idx++];
3384    QualType T
3385      = Context->getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
3386    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3387    return T;
3388  }
3389
3390  case TYPE_ATTRIBUTED: {
3391    if (Record.size() != 3) {
3392      Error("incorrect encoding of attributed type");
3393      return QualType();
3394    }
3395    QualType modifiedType = readType(*Loc.F, Record, Idx);
3396    QualType equivalentType = readType(*Loc.F, Record, Idx);
3397    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
3398    return Context->getAttributedType(kind, modifiedType, equivalentType);
3399  }
3400
3401  case TYPE_PAREN: {
3402    if (Record.size() != 1) {
3403      Error("incorrect encoding of paren type");
3404      return QualType();
3405    }
3406    QualType InnerType = readType(*Loc.F, Record, Idx);
3407    return Context->getParenType(InnerType);
3408  }
3409
3410  case TYPE_PACK_EXPANSION: {
3411    if (Record.size() != 2) {
3412      Error("incorrect encoding of pack expansion type");
3413      return QualType();
3414    }
3415    QualType Pattern = readType(*Loc.F, Record, Idx);
3416    if (Pattern.isNull())
3417      return QualType();
3418    llvm::Optional<unsigned> NumExpansions;
3419    if (Record[1])
3420      NumExpansions = Record[1] - 1;
3421    return Context->getPackExpansionType(Pattern, NumExpansions);
3422  }
3423
3424  case TYPE_ELABORATED: {
3425    unsigned Idx = 0;
3426    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3427    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3428    QualType NamedType = readType(*Loc.F, Record, Idx);
3429    return Context->getElaboratedType(Keyword, NNS, NamedType);
3430  }
3431
3432  case TYPE_OBJC_INTERFACE: {
3433    unsigned Idx = 0;
3434    ObjCInterfaceDecl *ItfD
3435      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
3436    return Context->getObjCInterfaceType(ItfD);
3437  }
3438
3439  case TYPE_OBJC_OBJECT: {
3440    unsigned Idx = 0;
3441    QualType Base = readType(*Loc.F, Record, Idx);
3442    unsigned NumProtos = Record[Idx++];
3443    SmallVector<ObjCProtocolDecl*, 4> Protos;
3444    for (unsigned I = 0; I != NumProtos; ++I)
3445      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
3446    return Context->getObjCObjectType(Base, Protos.data(), NumProtos);
3447  }
3448
3449  case TYPE_OBJC_OBJECT_POINTER: {
3450    unsigned Idx = 0;
3451    QualType Pointee = readType(*Loc.F, Record, Idx);
3452    return Context->getObjCObjectPointerType(Pointee);
3453  }
3454
3455  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
3456    unsigned Idx = 0;
3457    QualType Parm = readType(*Loc.F, Record, Idx);
3458    QualType Replacement = readType(*Loc.F, Record, Idx);
3459    return
3460      Context->getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
3461                                            Replacement);
3462  }
3463
3464  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
3465    unsigned Idx = 0;
3466    QualType Parm = readType(*Loc.F, Record, Idx);
3467    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
3468    return Context->getSubstTemplateTypeParmPackType(
3469                                               cast<TemplateTypeParmType>(Parm),
3470                                                     ArgPack);
3471  }
3472
3473  case TYPE_INJECTED_CLASS_NAME: {
3474    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
3475    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
3476    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
3477    // for AST reading, too much interdependencies.
3478    return
3479      QualType(new (*Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
3480  }
3481
3482  case TYPE_TEMPLATE_TYPE_PARM: {
3483    unsigned Idx = 0;
3484    unsigned Depth = Record[Idx++];
3485    unsigned Index = Record[Idx++];
3486    bool Pack = Record[Idx++];
3487    TemplateTypeParmDecl *D
3488      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
3489    return Context->getTemplateTypeParmType(Depth, Index, Pack, D);
3490  }
3491
3492  case TYPE_DEPENDENT_NAME: {
3493    unsigned Idx = 0;
3494    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3495    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3496    const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3497    QualType Canon = readType(*Loc.F, Record, Idx);
3498    if (!Canon.isNull())
3499      Canon = Context->getCanonicalType(Canon);
3500    return Context->getDependentNameType(Keyword, NNS, Name, Canon);
3501  }
3502
3503  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
3504    unsigned Idx = 0;
3505    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
3506    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
3507    const IdentifierInfo *Name = this->GetIdentifierInfo(Record, Idx);
3508    unsigned NumArgs = Record[Idx++];
3509    SmallVector<TemplateArgument, 8> Args;
3510    Args.reserve(NumArgs);
3511    while (NumArgs--)
3512      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
3513    return Context->getDependentTemplateSpecializationType(Keyword, NNS, Name,
3514                                                      Args.size(), Args.data());
3515  }
3516
3517  case TYPE_DEPENDENT_SIZED_ARRAY: {
3518    unsigned Idx = 0;
3519
3520    // ArrayType
3521    QualType ElementType = readType(*Loc.F, Record, Idx);
3522    ArrayType::ArraySizeModifier ASM
3523      = (ArrayType::ArraySizeModifier)Record[Idx++];
3524    unsigned IndexTypeQuals = Record[Idx++];
3525
3526    // DependentSizedArrayType
3527    Expr *NumElts = ReadExpr(*Loc.F);
3528    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
3529
3530    return Context->getDependentSizedArrayType(ElementType, NumElts, ASM,
3531                                               IndexTypeQuals, Brackets);
3532  }
3533
3534  case TYPE_TEMPLATE_SPECIALIZATION: {
3535    unsigned Idx = 0;
3536    bool IsDependent = Record[Idx++];
3537    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
3538    SmallVector<TemplateArgument, 8> Args;
3539    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
3540    QualType Underlying = readType(*Loc.F, Record, Idx);
3541    QualType T;
3542    if (Underlying.isNull())
3543      T = Context->getCanonicalTemplateSpecializationType(Name, Args.data(),
3544                                                          Args.size());
3545    else
3546      T = Context->getTemplateSpecializationType(Name, Args.data(),
3547                                                 Args.size(), Underlying);
3548    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
3549    return T;
3550  }
3551  }
3552  // Suppress a GCC warning
3553  return QualType();
3554}
3555
3556class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
3557  ASTReader &Reader;
3558  Module &F;
3559  llvm::BitstreamCursor &DeclsCursor;
3560  const ASTReader::RecordData &Record;
3561  unsigned &Idx;
3562
3563  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
3564                                    unsigned &I) {
3565    return Reader.ReadSourceLocation(F, R, I);
3566  }
3567
3568  template<typename T>
3569  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
3570    return Reader.ReadDeclAs<T>(F, Record, Idx);
3571  }
3572
3573public:
3574  TypeLocReader(ASTReader &Reader, Module &F,
3575                const ASTReader::RecordData &Record, unsigned &Idx)
3576    : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx)
3577  { }
3578
3579  // We want compile-time assurance that we've enumerated all of
3580  // these, so unfortunately we have to declare them first, then
3581  // define them out-of-line.
3582#define ABSTRACT_TYPELOC(CLASS, PARENT)
3583#define TYPELOC(CLASS, PARENT) \
3584  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
3585#include "clang/AST/TypeLocNodes.def"
3586
3587  void VisitFunctionTypeLoc(FunctionTypeLoc);
3588  void VisitArrayTypeLoc(ArrayTypeLoc);
3589};
3590
3591void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
3592  // nothing to do
3593}
3594void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
3595  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
3596  if (TL.needsExtraLocalData()) {
3597    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
3598    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
3599    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
3600    TL.setModeAttr(Record[Idx++]);
3601  }
3602}
3603void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
3604  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3605}
3606void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
3607  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3608}
3609void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
3610  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
3611}
3612void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
3613  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
3614}
3615void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
3616  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
3617}
3618void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
3619  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3620  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3621}
3622void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
3623  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
3624  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
3625  if (Record[Idx++])
3626    TL.setSizeExpr(Reader.ReadExpr(F));
3627  else
3628    TL.setSizeExpr(0);
3629}
3630void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
3631  VisitArrayTypeLoc(TL);
3632}
3633void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
3634  VisitArrayTypeLoc(TL);
3635}
3636void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
3637  VisitArrayTypeLoc(TL);
3638}
3639void TypeLocReader::VisitDependentSizedArrayTypeLoc(
3640                                            DependentSizedArrayTypeLoc TL) {
3641  VisitArrayTypeLoc(TL);
3642}
3643void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
3644                                        DependentSizedExtVectorTypeLoc TL) {
3645  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3646}
3647void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
3648  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3649}
3650void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
3651  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3652}
3653void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
3654  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
3655  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
3656  TL.setTrailingReturn(Record[Idx++]);
3657  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
3658    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
3659  }
3660}
3661void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
3662  VisitFunctionTypeLoc(TL);
3663}
3664void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
3665  VisitFunctionTypeLoc(TL);
3666}
3667void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
3668  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3669}
3670void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
3671  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3672}
3673void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
3674  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3675  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3676  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3677}
3678void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
3679  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
3680  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3681  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3682  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3683}
3684void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
3685  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3686}
3687void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
3688  TL.setKWLoc(ReadSourceLocation(Record, Idx));
3689  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3690  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3691  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
3692}
3693void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
3694  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3695}
3696void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
3697  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3698}
3699void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
3700  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3701}
3702void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
3703  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
3704  if (TL.hasAttrOperand()) {
3705    SourceRange range;
3706    range.setBegin(ReadSourceLocation(Record, Idx));
3707    range.setEnd(ReadSourceLocation(Record, Idx));
3708    TL.setAttrOperandParensRange(range);
3709  }
3710  if (TL.hasAttrExprOperand()) {
3711    if (Record[Idx++])
3712      TL.setAttrExprOperand(Reader.ReadExpr(F));
3713    else
3714      TL.setAttrExprOperand(0);
3715  } else if (TL.hasAttrEnumOperand())
3716    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
3717}
3718void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
3719  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3720}
3721void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
3722                                            SubstTemplateTypeParmTypeLoc TL) {
3723  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3724}
3725void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
3726                                          SubstTemplateTypeParmPackTypeLoc TL) {
3727  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3728}
3729void TypeLocReader::VisitTemplateSpecializationTypeLoc(
3730                                           TemplateSpecializationTypeLoc TL) {
3731  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
3732  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3733  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3734  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3735    TL.setArgLocInfo(i,
3736        Reader.GetTemplateArgumentLocInfo(F,
3737                                          TL.getTypePtr()->getArg(i).getKind(),
3738                                          Record, Idx));
3739}
3740void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
3741  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
3742  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
3743}
3744void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
3745  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3746  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3747}
3748void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
3749  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3750}
3751void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
3752  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3753  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3754  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3755}
3756void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
3757       DependentTemplateSpecializationTypeLoc TL) {
3758  TL.setKeywordLoc(ReadSourceLocation(Record, Idx));
3759  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
3760  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3761  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3762  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3763  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
3764    TL.setArgLocInfo(I,
3765        Reader.GetTemplateArgumentLocInfo(F,
3766                                          TL.getTypePtr()->getArg(I).getKind(),
3767                                          Record, Idx));
3768}
3769void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
3770  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
3771}
3772void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
3773  TL.setNameLoc(ReadSourceLocation(Record, Idx));
3774}
3775void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
3776  TL.setHasBaseTypeAsWritten(Record[Idx++]);
3777  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
3778  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
3779  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
3780    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
3781}
3782void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
3783  TL.setStarLoc(ReadSourceLocation(Record, Idx));
3784}
3785
3786TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F,
3787                                             const RecordData &Record,
3788                                             unsigned &Idx) {
3789  QualType InfoTy = readType(F, Record, Idx);
3790  if (InfoTy.isNull())
3791    return 0;
3792
3793  TypeSourceInfo *TInfo = getContext()->CreateTypeSourceInfo(InfoTy);
3794  TypeLocReader TLR(*this, F, Record, Idx);
3795  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
3796    TLR.Visit(TL);
3797  return TInfo;
3798}
3799
3800QualType ASTReader::GetType(TypeID ID) {
3801  unsigned FastQuals = ID & Qualifiers::FastMask;
3802  unsigned Index = ID >> Qualifiers::FastWidth;
3803
3804  if (Index < NUM_PREDEF_TYPE_IDS) {
3805    QualType T;
3806    switch ((PredefinedTypeIDs)Index) {
3807    case PREDEF_TYPE_NULL_ID: return QualType();
3808    case PREDEF_TYPE_VOID_ID: T = Context->VoidTy; break;
3809    case PREDEF_TYPE_BOOL_ID: T = Context->BoolTy; break;
3810
3811    case PREDEF_TYPE_CHAR_U_ID:
3812    case PREDEF_TYPE_CHAR_S_ID:
3813      // FIXME: Check that the signedness of CharTy is correct!
3814      T = Context->CharTy;
3815      break;
3816
3817    case PREDEF_TYPE_UCHAR_ID:      T = Context->UnsignedCharTy;     break;
3818    case PREDEF_TYPE_USHORT_ID:     T = Context->UnsignedShortTy;    break;
3819    case PREDEF_TYPE_UINT_ID:       T = Context->UnsignedIntTy;      break;
3820    case PREDEF_TYPE_ULONG_ID:      T = Context->UnsignedLongTy;     break;
3821    case PREDEF_TYPE_ULONGLONG_ID:  T = Context->UnsignedLongLongTy; break;
3822    case PREDEF_TYPE_UINT128_ID:    T = Context->UnsignedInt128Ty;   break;
3823    case PREDEF_TYPE_SCHAR_ID:      T = Context->SignedCharTy;       break;
3824    case PREDEF_TYPE_WCHAR_ID:      T = Context->WCharTy;            break;
3825    case PREDEF_TYPE_SHORT_ID:      T = Context->ShortTy;            break;
3826    case PREDEF_TYPE_INT_ID:        T = Context->IntTy;              break;
3827    case PREDEF_TYPE_LONG_ID:       T = Context->LongTy;             break;
3828    case PREDEF_TYPE_LONGLONG_ID:   T = Context->LongLongTy;         break;
3829    case PREDEF_TYPE_INT128_ID:     T = Context->Int128Ty;           break;
3830    case PREDEF_TYPE_FLOAT_ID:      T = Context->FloatTy;            break;
3831    case PREDEF_TYPE_DOUBLE_ID:     T = Context->DoubleTy;           break;
3832    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context->LongDoubleTy;       break;
3833    case PREDEF_TYPE_OVERLOAD_ID:   T = Context->OverloadTy;         break;
3834    case PREDEF_TYPE_BOUND_MEMBER:  T = Context->BoundMemberTy;      break;
3835    case PREDEF_TYPE_DEPENDENT_ID:  T = Context->DependentTy;        break;
3836    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context->UnknownAnyTy;       break;
3837    case PREDEF_TYPE_NULLPTR_ID:    T = Context->NullPtrTy;          break;
3838    case PREDEF_TYPE_CHAR16_ID:     T = Context->Char16Ty;           break;
3839    case PREDEF_TYPE_CHAR32_ID:     T = Context->Char32Ty;           break;
3840    case PREDEF_TYPE_OBJC_ID:       T = Context->ObjCBuiltinIdTy;    break;
3841    case PREDEF_TYPE_OBJC_CLASS:    T = Context->ObjCBuiltinClassTy; break;
3842    case PREDEF_TYPE_OBJC_SEL:      T = Context->ObjCBuiltinSelTy;   break;
3843    }
3844
3845    assert(!T.isNull() && "Unknown predefined type");
3846    return T.withFastQualifiers(FastQuals);
3847  }
3848
3849  Index -= NUM_PREDEF_TYPE_IDS;
3850  assert(Index < TypesLoaded.size() && "Type index out-of-range");
3851  if (TypesLoaded[Index].isNull()) {
3852    TypesLoaded[Index] = readTypeRecord(Index);
3853    if (TypesLoaded[Index].isNull())
3854      return QualType();
3855
3856    TypesLoaded[Index]->setFromAST();
3857    TypeIdxs[TypesLoaded[Index]] = TypeIdx::fromTypeID(ID);
3858    if (DeserializationListener)
3859      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
3860                                        TypesLoaded[Index]);
3861  }
3862
3863  return TypesLoaded[Index].withFastQualifiers(FastQuals);
3864}
3865
3866QualType ASTReader::getLocalType(Module &F, unsigned LocalID) {
3867  return GetType(getGlobalTypeID(F, LocalID));
3868}
3869
3870serialization::TypeID
3871ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const {
3872  // FIXME: Map from local type ID to global type ID.
3873  return LocalID;
3874}
3875
3876TypeID ASTReader::GetTypeID(QualType T) const {
3877  return MakeTypeID(T,
3878              std::bind1st(std::mem_fun(&ASTReader::GetTypeIdx), this));
3879}
3880
3881TypeIdx ASTReader::GetTypeIdx(QualType T) const {
3882  if (T.isNull())
3883    return TypeIdx();
3884  assert(!T.getLocalFastQualifiers());
3885
3886  TypeIdxMap::const_iterator I = TypeIdxs.find(T);
3887  // GetTypeIdx is mostly used for computing the hash of DeclarationNames and
3888  // comparing keys of ASTDeclContextNameLookupTable.
3889  // If the type didn't come from the AST file use a specially marked index
3890  // so that any hash/key comparison fail since no such index is stored
3891  // in a AST file.
3892  if (I == TypeIdxs.end())
3893    return TypeIdx(-1);
3894  return I->second;
3895}
3896
3897TemplateArgumentLocInfo
3898ASTReader::GetTemplateArgumentLocInfo(Module &F,
3899                                      TemplateArgument::ArgKind Kind,
3900                                      const RecordData &Record,
3901                                      unsigned &Index) {
3902  switch (Kind) {
3903  case TemplateArgument::Expression:
3904    return ReadExpr(F);
3905  case TemplateArgument::Type:
3906    return GetTypeSourceInfo(F, Record, Index);
3907  case TemplateArgument::Template: {
3908    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3909                                                                     Index);
3910    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3911    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3912                                   SourceLocation());
3913  }
3914  case TemplateArgument::TemplateExpansion: {
3915    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
3916                                                                     Index);
3917    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
3918    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
3919    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
3920                                   EllipsisLoc);
3921  }
3922  case TemplateArgument::Null:
3923  case TemplateArgument::Integral:
3924  case TemplateArgument::Declaration:
3925  case TemplateArgument::Pack:
3926    return TemplateArgumentLocInfo();
3927  }
3928  llvm_unreachable("unexpected template argument loc");
3929  return TemplateArgumentLocInfo();
3930}
3931
3932TemplateArgumentLoc
3933ASTReader::ReadTemplateArgumentLoc(Module &F,
3934                                   const RecordData &Record, unsigned &Index) {
3935  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
3936
3937  if (Arg.getKind() == TemplateArgument::Expression) {
3938    if (Record[Index++]) // bool InfoHasSameExpr.
3939      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
3940  }
3941  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
3942                                                             Record, Index));
3943}
3944
3945Decl *ASTReader::GetExternalDecl(uint32_t ID) {
3946  return GetDecl(ID);
3947}
3948
3949uint64_t
3950ASTReader::GetCXXBaseSpecifiersOffset(serialization::CXXBaseSpecifiersID ID) {
3951  if (ID == 0)
3952    return 0;
3953
3954  GlobalCXXBaseSpecifiersMapType::iterator I =
3955      GlobalCXXBaseSpecifiersMap.find(ID);
3956
3957  assert (I != GlobalCXXBaseSpecifiersMap.end() &&
3958                                    "Corrupted global CXX base specifiers map");
3959
3960  return I->second.first->CXXBaseSpecifiersOffsets[ID - 1 +
3961                                               I->second.second] +
3962                                               I->second.first->GlobalBitOffset;
3963
3964}
3965
3966CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
3967  RecordLocation Loc = getLocalBitOffset(Offset);
3968  llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor;
3969  SavedStreamPosition SavedPosition(Cursor);
3970  Cursor.JumpToBit(Loc.Offset);
3971  ReadingKindTracker ReadingKind(Read_Decl, *this);
3972  RecordData Record;
3973  unsigned Code = Cursor.ReadCode();
3974  unsigned RecCode = Cursor.ReadRecord(Code, Record);
3975  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
3976    Error("Malformed AST file: missing C++ base specifiers");
3977    return 0;
3978  }
3979
3980  unsigned Idx = 0;
3981  unsigned NumBases = Record[Idx++];
3982  void *Mem = Context->Allocate(sizeof(CXXBaseSpecifier) * NumBases);
3983  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
3984  for (unsigned I = 0; I != NumBases; ++I)
3985    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
3986  return Bases;
3987}
3988
3989TranslationUnitDecl *ASTReader::GetTranslationUnitDecl() {
3990  if (!DeclsLoaded[0]) {
3991    ReadDeclRecord(0, 1);
3992    if (DeserializationListener)
3993      DeserializationListener->DeclRead(1, DeclsLoaded[0]);
3994  }
3995
3996  return cast<TranslationUnitDecl>(DeclsLoaded[0]);
3997}
3998
3999serialization::DeclID
4000ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const {
4001  // FIXME: Perform local -> global remapping for declarations.
4002  return LocalID;
4003}
4004
4005Decl *ASTReader::GetDecl(DeclID ID) {
4006  if (ID == 0)
4007    return 0;
4008
4009  if (ID > DeclsLoaded.size()) {
4010    Error("declaration ID out-of-range for AST file");
4011    return 0;
4012  }
4013
4014  unsigned Index = ID - 1;
4015  if (!DeclsLoaded[Index]) {
4016    ReadDeclRecord(Index, ID);
4017    if (DeserializationListener)
4018      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
4019  }
4020
4021  return DeclsLoaded[Index];
4022}
4023
4024serialization::DeclID ASTReader::ReadDeclID(Module &F,
4025                                            const RecordData &Record,
4026                                            unsigned &Idx) {
4027  if (Idx >= Record.size()) {
4028    Error("Corrupted AST file");
4029    return 0;
4030  }
4031
4032  return getGlobalDeclID(F, Record[Idx++]);
4033}
4034
4035/// \brief Resolve the offset of a statement into a statement.
4036///
4037/// This operation will read a new statement from the external
4038/// source each time it is called, and is meant to be used via a
4039/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
4040Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
4041  // Switch case IDs are per Decl.
4042  ClearSwitchCaseIDs();
4043
4044  // Offset here is a global offset across the entire chain.
4045  RecordLocation Loc = getLocalBitOffset(Offset);
4046  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
4047  return ReadStmtFromStream(*Loc.F);
4048}
4049
4050ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
4051                                         bool (*isKindWeWant)(Decl::Kind),
4052                                         SmallVectorImpl<Decl*> &Decls) {
4053  // There might be lexical decls in multiple parts of the chain, for the TU
4054  // at least.
4055  // DeclContextOffsets might reallocate as we load additional decls below,
4056  // so make a copy of the vector.
4057  DeclContextInfos Infos = DeclContextOffsets[DC];
4058  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4059       I != E; ++I) {
4060    // IDs can be 0 if this context doesn't contain declarations.
4061    if (!I->LexicalDecls)
4062      continue;
4063
4064    // Load all of the declaration IDs
4065    for (const KindDeclIDPair *ID = I->LexicalDecls,
4066                              *IDE = ID + I->NumLexicalDecls; ID != IDE; ++ID) {
4067      if (isKindWeWant && !isKindWeWant((Decl::Kind)ID->first))
4068        continue;
4069
4070      Decl *D = GetLocalDecl(*I->F, ID->second);
4071      assert(D && "Null decl in lexical decls");
4072      Decls.push_back(D);
4073    }
4074  }
4075
4076  ++NumLexicalDeclContextsRead;
4077  return ELR_Success;
4078}
4079
4080DeclContext::lookup_result
4081ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
4082                                          DeclarationName Name) {
4083  assert(DC->hasExternalVisibleStorage() &&
4084         "DeclContext has no visible decls in storage");
4085  if (!Name)
4086    return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
4087                                      DeclContext::lookup_iterator(0));
4088
4089  SmallVector<NamedDecl *, 64> Decls;
4090  // There might be visible decls in multiple parts of the chain, for the TU
4091  // and namespaces. For any given name, the last available results replace
4092  // all earlier ones. For this reason, we walk in reverse.
4093  DeclContextInfos &Infos = DeclContextOffsets[DC];
4094  for (DeclContextInfos::reverse_iterator I = Infos.rbegin(), E = Infos.rend();
4095       I != E; ++I) {
4096    if (!I->NameLookupTableData)
4097      continue;
4098
4099    ASTDeclContextNameLookupTable *LookupTable =
4100        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4101    ASTDeclContextNameLookupTable::iterator Pos = LookupTable->find(Name);
4102    if (Pos == LookupTable->end())
4103      continue;
4104
4105    ASTDeclContextNameLookupTrait::data_type Data = *Pos;
4106    for (; Data.first != Data.second; ++Data.first)
4107      Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
4108    break;
4109  }
4110
4111  ++NumVisibleDeclContextsRead;
4112
4113  SetExternalVisibleDeclsForName(DC, Name, Decls);
4114  return const_cast<DeclContext*>(DC)->lookup(Name);
4115}
4116
4117void ASTReader::MaterializeVisibleDecls(const DeclContext *DC) {
4118  assert(DC->hasExternalVisibleStorage() &&
4119         "DeclContext has no visible decls in storage");
4120
4121  SmallVector<NamedDecl *, 64> Decls;
4122  // There might be visible decls in multiple parts of the chain, for the TU
4123  // and namespaces.
4124  DeclContextInfos &Infos = DeclContextOffsets[DC];
4125  for (DeclContextInfos::iterator I = Infos.begin(), E = Infos.end();
4126       I != E; ++I) {
4127    if (!I->NameLookupTableData)
4128      continue;
4129
4130    ASTDeclContextNameLookupTable *LookupTable =
4131        (ASTDeclContextNameLookupTable*)I->NameLookupTableData;
4132    for (ASTDeclContextNameLookupTable::item_iterator
4133           ItemI = LookupTable->item_begin(),
4134           ItemEnd = LookupTable->item_end() ; ItemI != ItemEnd; ++ItemI) {
4135      ASTDeclContextNameLookupTable::item_iterator::value_type Val
4136          = *ItemI;
4137      ASTDeclContextNameLookupTrait::data_type Data = Val.second;
4138      Decls.clear();
4139      for (; Data.first != Data.second; ++Data.first)
4140        Decls.push_back(GetLocalDeclAs<NamedDecl>(*I->F, *Data.first));
4141      MaterializeVisibleDeclsForName(DC, Val.first, Decls);
4142    }
4143  }
4144}
4145
4146void ASTReader::PassInterestingDeclsToConsumer() {
4147  assert(Consumer);
4148  while (!InterestingDecls.empty()) {
4149    DeclGroupRef DG(InterestingDecls.front());
4150    InterestingDecls.pop_front();
4151    Consumer->HandleInterestingDecl(DG);
4152  }
4153}
4154
4155void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
4156  this->Consumer = Consumer;
4157
4158  if (!Consumer)
4159    return;
4160
4161  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
4162    // Force deserialization of this decl, which will cause it to be queued for
4163    // passing to the consumer.
4164    GetDecl(ExternalDefinitions[I]);
4165  }
4166
4167  PassInterestingDeclsToConsumer();
4168}
4169
4170void ASTReader::PrintStats() {
4171  std::fprintf(stderr, "*** AST File Statistics:\n");
4172
4173  unsigned NumTypesLoaded
4174    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
4175                                      QualType());
4176  unsigned NumDeclsLoaded
4177    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
4178                                      (Decl *)0);
4179  unsigned NumIdentifiersLoaded
4180    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
4181                                            IdentifiersLoaded.end(),
4182                                            (IdentifierInfo *)0);
4183  unsigned NumSelectorsLoaded
4184    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
4185                                          SelectorsLoaded.end(),
4186                                          Selector());
4187
4188  std::fprintf(stderr, "  %u stat cache hits\n", NumStatHits);
4189  std::fprintf(stderr, "  %u stat cache misses\n", NumStatMisses);
4190  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
4191    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
4192                 NumSLocEntriesRead, TotalNumSLocEntries,
4193                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
4194  if (!TypesLoaded.empty())
4195    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
4196                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
4197                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
4198  if (!DeclsLoaded.empty())
4199    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
4200                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
4201                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
4202  if (!IdentifiersLoaded.empty())
4203    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
4204                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
4205                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
4206  if (!SelectorsLoaded.empty())
4207    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
4208                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
4209                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
4210  if (TotalNumStatements)
4211    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
4212                 NumStatementsRead, TotalNumStatements,
4213                 ((float)NumStatementsRead/TotalNumStatements * 100));
4214  if (TotalNumMacros)
4215    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
4216                 NumMacrosRead, TotalNumMacros,
4217                 ((float)NumMacrosRead/TotalNumMacros * 100));
4218  if (TotalLexicalDeclContexts)
4219    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
4220                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
4221                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
4222                  * 100));
4223  if (TotalVisibleDeclContexts)
4224    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
4225                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
4226                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
4227                  * 100));
4228  if (TotalNumMethodPoolEntries) {
4229    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
4230                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
4231                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
4232                  * 100));
4233    std::fprintf(stderr, "  %u method pool misses\n", NumMethodPoolMisses);
4234  }
4235  std::fprintf(stderr, "\n");
4236  dump();
4237  std::fprintf(stderr, "\n");
4238}
4239
4240template<typename Key, typename Module, unsigned InitialCapacity>
4241static void
4242dumpModuleIDMap(StringRef Name,
4243                const ContinuousRangeMap<Key, Module *,
4244                                         InitialCapacity> &Map) {
4245  if (Map.begin() == Map.end())
4246    return;
4247
4248  typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType;
4249  llvm::errs() << Name << ":\n";
4250  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4251       I != IEnd; ++I) {
4252    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
4253      << "\n";
4254  }
4255}
4256
4257template<typename Key, typename Module, typename Adjustment,
4258         unsigned InitialCapacity>
4259static void
4260dumpModuleIDOffsetMap(StringRef Name,
4261                      const ContinuousRangeMap<Key,
4262                                               std::pair<Module *,
4263                                                         Adjustment>,
4264                                               InitialCapacity> &Map) {
4265  if (Map.begin() == Map.end())
4266    return;
4267
4268  typedef ContinuousRangeMap<Key, std::pair<Module *, Adjustment>,
4269                             InitialCapacity> MapType;
4270  llvm::errs() << Name << ":\n";
4271  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
4272       I != IEnd; ++I) {
4273    llvm::errs() << "  " << I->first << " -> (" << I->second.first->FileName
4274                 << ", " << I->second.second << ")\n";
4275  }
4276}
4277
4278void ASTReader::dump() {
4279  llvm::errs() << "*** AST File Remapping:\n";
4280  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
4281  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
4282  dumpModuleIDOffsetMap("Global type map", GlobalTypeMap);
4283  dumpModuleIDOffsetMap("Global declaration map", GlobalDeclMap);
4284  dumpModuleIDOffsetMap("Global identifier map", GlobalIdentifierMap);
4285  dumpModuleIDOffsetMap("Global selector map", GlobalSelectorMap);
4286  dumpModuleIDOffsetMap("Global macro definition map",
4287                        GlobalMacroDefinitionMap);
4288  dumpModuleIDOffsetMap("Global preprocessed entity map",
4289                        GlobalPreprocessedEntityMap);
4290
4291}
4292
4293/// Return the amount of memory used by memory buffers, breaking down
4294/// by heap-backed versus mmap'ed memory.
4295void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
4296  for (ModuleConstIterator I = ModuleMgr.begin(),
4297      E = ModuleMgr.end(); I != E; ++I) {
4298    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
4299      size_t bytes = buf->getBufferSize();
4300      switch (buf->getBufferKind()) {
4301        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
4302          sizes.malloc_bytes += bytes;
4303          break;
4304        case llvm::MemoryBuffer::MemoryBuffer_MMap:
4305          sizes.mmap_bytes += bytes;
4306          break;
4307      }
4308    }
4309  }
4310}
4311
4312void ASTReader::InitializeSema(Sema &S) {
4313  SemaObj = &S;
4314  S.ExternalSource = this;
4315
4316  // Makes sure any declarations that were deserialized "too early"
4317  // still get added to the identifier's declaration chains.
4318  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
4319    if (SemaObj->TUScope)
4320      SemaObj->TUScope->AddDecl(PreloadedDecls[I]);
4321
4322    SemaObj->IdResolver.AddDecl(PreloadedDecls[I]);
4323  }
4324  PreloadedDecls.clear();
4325
4326  // If there were any tentative definitions, deserialize them and add
4327  // them to Sema's list of tentative definitions.
4328  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
4329    VarDecl *Var = cast<VarDecl>(GetDecl(TentativeDefinitions[I]));
4330    SemaObj->TentativeDefinitions.push_back(Var);
4331  }
4332
4333  // If there were any unused file scoped decls, deserialize them and add to
4334  // Sema's list of unused file scoped decls.
4335  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
4336    DeclaratorDecl *D = cast<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
4337    SemaObj->UnusedFileScopedDecls.push_back(D);
4338  }
4339
4340  // If there were any delegating constructors, add them to Sema's list
4341  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
4342    CXXConstructorDecl *D
4343     = cast<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
4344    SemaObj->DelegatingCtorDecls.push_back(D);
4345  }
4346
4347  // If there were any locally-scoped external declarations,
4348  // deserialize them and add them to Sema's table of locally-scoped
4349  // external declarations.
4350  for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) {
4351    NamedDecl *D = cast<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I]));
4352    SemaObj->LocallyScopedExternalDecls[D->getDeclName()] = D;
4353  }
4354
4355  // If there were any ext_vector type declarations, deserialize them
4356  // and add them to Sema's vector of such declarations.
4357  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I)
4358    SemaObj->ExtVectorDecls.push_back(
4359                             cast<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])));
4360
4361  // FIXME: Do VTable uses and dynamic classes deserialize too much ?
4362  // Can we cut them down before writing them ?
4363
4364  // If there were any dynamic classes declarations, deserialize them
4365  // and add them to Sema's vector of such declarations.
4366  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I)
4367    SemaObj->DynamicClasses.push_back(
4368                               cast<CXXRecordDecl>(GetDecl(DynamicClasses[I])));
4369
4370  // Load the offsets of the declarations that Sema references.
4371  // They will be lazily deserialized when needed.
4372  if (!SemaDeclRefs.empty()) {
4373    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
4374    SemaObj->StdNamespace = SemaDeclRefs[0];
4375    SemaObj->StdBadAlloc = SemaDeclRefs[1];
4376  }
4377
4378  for (Module *F = &ModuleMgr.getPrimaryModule(); F; F = F->NextInSource) {
4379
4380    // If there are @selector references added them to its pool. This is for
4381    // implementation of -Wselector.
4382    if (!F->ReferencedSelectorsData.empty()) {
4383      unsigned int DataSize = F->ReferencedSelectorsData.size()-1;
4384      unsigned I = 0;
4385      while (I < DataSize) {
4386        Selector Sel = DecodeSelector(F->ReferencedSelectorsData[I++]);
4387        SourceLocation SelLoc = ReadSourceLocation(
4388                                    *F, F->ReferencedSelectorsData, I);
4389        SemaObj->ReferencedSelectors.insert(std::make_pair(Sel, SelLoc));
4390      }
4391    }
4392  }
4393
4394  // The special data sets below always come from the most recent PCH,
4395  // which is at the front of the chain.
4396  Module &F = ModuleMgr.getPrimaryModule();
4397
4398  // If there were any pending implicit instantiations, deserialize them
4399  // and add them to Sema's queue of such instantiations.
4400  assert(F.PendingInstantiations.size() % 2 == 0 &&
4401         "Expected pairs of entries");
4402  for (unsigned Idx = 0, N = F.PendingInstantiations.size(); Idx < N;) {
4403    ValueDecl *D=cast<ValueDecl>(GetDecl(F.PendingInstantiations[Idx++]));
4404    SourceLocation Loc = ReadSourceLocation(F, F.PendingInstantiations,Idx);
4405    SemaObj->PendingInstantiations.push_back(std::make_pair(D, Loc));
4406  }
4407
4408  // If there were any weak undeclared identifiers, deserialize them and add to
4409  // Sema's list of weak undeclared identifiers.
4410  if (!WeakUndeclaredIdentifiers.empty()) {
4411    unsigned Idx = 0;
4412    for (unsigned I = 0, N = WeakUndeclaredIdentifiers[Idx++]; I != N; ++I) {
4413      IdentifierInfo *WeakId = GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4414      IdentifierInfo *AliasId= GetIdentifierInfo(WeakUndeclaredIdentifiers,Idx);
4415      SourceLocation Loc = ReadSourceLocation(F, WeakUndeclaredIdentifiers,Idx);
4416      bool Used = WeakUndeclaredIdentifiers[Idx++];
4417      Sema::WeakInfo WI(AliasId, Loc);
4418      WI.setUsed(Used);
4419      SemaObj->WeakUndeclaredIdentifiers.insert(std::make_pair(WeakId, WI));
4420    }
4421  }
4422
4423  // If there were any VTable uses, deserialize the information and add it
4424  // to Sema's vector and map of VTable uses.
4425  if (!VTableUses.empty()) {
4426    unsigned Idx = 0;
4427    for (unsigned I = 0, N = VTableUses[Idx++]; I != N; ++I) {
4428      CXXRecordDecl *Class = cast<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
4429      SourceLocation Loc = ReadSourceLocation(F, VTableUses, Idx);
4430      bool DefinitionRequired = VTableUses[Idx++];
4431      SemaObj->VTableUses.push_back(std::make_pair(Class, Loc));
4432      SemaObj->VTablesUsed[Class] = DefinitionRequired;
4433    }
4434  }
4435
4436  if (!FPPragmaOptions.empty()) {
4437    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
4438    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
4439  }
4440
4441  if (!OpenCLExtensions.empty()) {
4442    unsigned I = 0;
4443#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
4444#include "clang/Basic/OpenCLExtensions.def"
4445
4446    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
4447  }
4448}
4449
4450IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
4451  // Try to find this name within our on-disk hash tables. We start with the
4452  // most recent one, since that one contains the most up-to-date info.
4453  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4454    ASTIdentifierLookupTable *IdTable
4455        = (ASTIdentifierLookupTable *)(*I)->IdentifierLookupTable;
4456    if (!IdTable)
4457      continue;
4458    std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart);
4459    ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key);
4460    if (Pos == IdTable->end())
4461      continue;
4462
4463    // Dereferencing the iterator has the effect of building the
4464    // IdentifierInfo node and populating it with the various
4465    // declarations it needs.
4466    return *Pos;
4467  }
4468  return 0;
4469}
4470
4471namespace clang {
4472  /// \brief An identifier-lookup iterator that enumerates all of the
4473  /// identifiers stored within a set of AST files.
4474  class ASTIdentifierIterator : public IdentifierIterator {
4475    /// \brief The AST reader whose identifiers are being enumerated.
4476    const ASTReader &Reader;
4477
4478    /// \brief The current index into the chain of AST files stored in
4479    /// the AST reader.
4480    unsigned Index;
4481
4482    /// \brief The current position within the identifier lookup table
4483    /// of the current AST file.
4484    ASTIdentifierLookupTable::key_iterator Current;
4485
4486    /// \brief The end position within the identifier lookup table of
4487    /// the current AST file.
4488    ASTIdentifierLookupTable::key_iterator End;
4489
4490  public:
4491    explicit ASTIdentifierIterator(const ASTReader &Reader);
4492
4493    virtual StringRef Next();
4494  };
4495}
4496
4497ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
4498  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
4499  ASTIdentifierLookupTable *IdTable
4500    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
4501  Current = IdTable->key_begin();
4502  End = IdTable->key_end();
4503}
4504
4505StringRef ASTIdentifierIterator::Next() {
4506  while (Current == End) {
4507    // If we have exhausted all of our AST files, we're done.
4508    if (Index == 0)
4509      return StringRef();
4510
4511    --Index;
4512    ASTIdentifierLookupTable *IdTable
4513      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
4514        IdentifierLookupTable;
4515    Current = IdTable->key_begin();
4516    End = IdTable->key_end();
4517  }
4518
4519  // We have any identifiers remaining in the current AST file; return
4520  // the next one.
4521  std::pair<const char*, unsigned> Key = *Current;
4522  ++Current;
4523  return StringRef(Key.first, Key.second);
4524}
4525
4526IdentifierIterator *ASTReader::getIdentifiers() const {
4527  return new ASTIdentifierIterator(*this);
4528}
4529
4530std::pair<ObjCMethodList, ObjCMethodList>
4531ASTReader::ReadMethodPool(Selector Sel) {
4532  // Find this selector in a hash table. We want to find the most recent entry.
4533  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4534    Module &F = *(*I);
4535    if (!F.SelectorLookupTable)
4536      continue;
4537
4538    ASTSelectorLookupTable *PoolTable
4539      = (ASTSelectorLookupTable*)F.SelectorLookupTable;
4540    ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
4541    if (Pos != PoolTable->end()) {
4542      ++NumSelectorsRead;
4543      // FIXME: Not quite happy with the statistics here. We probably should
4544      // disable this tracking when called via LoadSelector.
4545      // Also, should entries without methods count as misses?
4546      ++NumMethodPoolEntriesRead;
4547      ASTSelectorLookupTrait::data_type Data = *Pos;
4548      if (DeserializationListener)
4549        DeserializationListener->SelectorRead(Data.ID, Sel);
4550      return std::make_pair(Data.Instance, Data.Factory);
4551    }
4552  }
4553
4554  ++NumMethodPoolMisses;
4555  return std::pair<ObjCMethodList, ObjCMethodList>();
4556}
4557
4558void ASTReader::ReadKnownNamespaces(
4559                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
4560  Namespaces.clear();
4561
4562  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
4563    if (NamespaceDecl *Namespace
4564                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
4565      Namespaces.push_back(Namespace);
4566  }
4567}
4568
4569void ASTReader::LoadSelector(Selector Sel) {
4570  // It would be complicated to avoid reading the methods anyway. So don't.
4571  ReadMethodPool(Sel);
4572}
4573
4574void ASTReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) {
4575  assert(ID && "Non-zero identifier ID required");
4576  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
4577  IdentifiersLoaded[ID - 1] = II;
4578  if (DeserializationListener)
4579    DeserializationListener->IdentifierRead(ID, II);
4580}
4581
4582/// \brief Set the globally-visible declarations associated with the given
4583/// identifier.
4584///
4585/// If the AST reader is currently in a state where the given declaration IDs
4586/// cannot safely be resolved, they are queued until it is safe to resolve
4587/// them.
4588///
4589/// \param II an IdentifierInfo that refers to one or more globally-visible
4590/// declarations.
4591///
4592/// \param DeclIDs the set of declaration IDs with the name @p II that are
4593/// visible at global scope.
4594///
4595/// \param Nonrecursive should be true to indicate that the caller knows that
4596/// this call is non-recursive, and therefore the globally-visible declarations
4597/// will not be placed onto the pending queue.
4598void
4599ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
4600                              const SmallVectorImpl<uint32_t> &DeclIDs,
4601                                   bool Nonrecursive) {
4602  if (NumCurrentElementsDeserializing && !Nonrecursive) {
4603    PendingIdentifierInfos.push_back(PendingIdentifierInfo());
4604    PendingIdentifierInfo &PII = PendingIdentifierInfos.back();
4605    PII.II = II;
4606    PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end());
4607    return;
4608  }
4609
4610  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
4611    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
4612    if (SemaObj) {
4613      if (SemaObj->TUScope) {
4614        // Introduce this declaration into the translation-unit scope
4615        // and add it to the declaration chain for this identifier, so
4616        // that (unqualified) name lookup will find it.
4617        SemaObj->TUScope->AddDecl(D);
4618      }
4619      SemaObj->IdResolver.AddDeclToIdentifierChain(II, D);
4620    } else {
4621      // Queue this declaration so that it will be added to the
4622      // translation unit scope and identifier's declaration chain
4623      // once a Sema object is known.
4624      PreloadedDecls.push_back(D);
4625    }
4626  }
4627}
4628
4629IdentifierInfo *ASTReader::DecodeIdentifierInfo(unsigned ID) {
4630  if (ID == 0)
4631    return 0;
4632
4633  if (IdentifiersLoaded.empty()) {
4634    Error("no identifier table in AST file");
4635    return 0;
4636  }
4637
4638  assert(PP && "Forgot to set Preprocessor ?");
4639  ID -= 1;
4640  if (!IdentifiersLoaded[ID]) {
4641    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
4642    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
4643    unsigned Index = ID + I->second.second;
4644    const char *Str = I->second.first->IdentifierTableData
4645                    + I->second.first->IdentifierOffsets[Index];
4646
4647    // All of the strings in the AST file are preceded by a 16-bit length.
4648    // Extract that 16-bit length to avoid having to execute strlen().
4649    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
4650    //  unsigned integers.  This is important to avoid integer overflow when
4651    //  we cast them to 'unsigned'.
4652    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
4653    unsigned StrLen = (((unsigned) StrLenPtr[0])
4654                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
4655    IdentifiersLoaded[ID]
4656      = &PP->getIdentifierTable().get(StringRef(Str, StrLen));
4657    if (DeserializationListener)
4658      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
4659  }
4660
4661  return IdentifiersLoaded[ID];
4662}
4663
4664bool ASTReader::ReadSLocEntry(int ID) {
4665  return ReadSLocEntryRecord(ID) != Success;
4666}
4667
4668Selector ASTReader::DecodeSelector(unsigned ID) {
4669  if (ID == 0)
4670    return Selector();
4671
4672  if (ID > SelectorsLoaded.size()) {
4673    Error("selector ID out of range in AST file");
4674    return Selector();
4675  }
4676
4677  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
4678    // Load this selector from the selector table.
4679    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
4680    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
4681    Module &F = *I->second.first;
4682    ASTSelectorLookupTrait Trait(*this, F);
4683    unsigned Idx = ID - 1 + I->second.second;
4684    SelectorsLoaded[ID - 1] =
4685      Trait.ReadKey(F.SelectorLookupTableData + F.SelectorOffsets[Idx], 0);
4686    if (DeserializationListener)
4687      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
4688  }
4689
4690  return SelectorsLoaded[ID - 1];
4691}
4692
4693Selector ASTReader::GetExternalSelector(uint32_t ID) {
4694  return DecodeSelector(ID);
4695}
4696
4697uint32_t ASTReader::GetNumExternalSelectors() {
4698  // ID 0 (the null selector) is considered an external selector.
4699  return getTotalNumSelectors() + 1;
4700}
4701
4702DeclarationName
4703ASTReader::ReadDeclarationName(Module &F,
4704                               const RecordData &Record, unsigned &Idx) {
4705  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
4706  switch (Kind) {
4707  case DeclarationName::Identifier:
4708    return DeclarationName(GetIdentifierInfo(Record, Idx));
4709
4710  case DeclarationName::ObjCZeroArgSelector:
4711  case DeclarationName::ObjCOneArgSelector:
4712  case DeclarationName::ObjCMultiArgSelector:
4713    return DeclarationName(GetSelector(Record, Idx));
4714
4715  case DeclarationName::CXXConstructorName:
4716    return Context->DeclarationNames.getCXXConstructorName(
4717                          Context->getCanonicalType(readType(F, Record, Idx)));
4718
4719  case DeclarationName::CXXDestructorName:
4720    return Context->DeclarationNames.getCXXDestructorName(
4721                          Context->getCanonicalType(readType(F, Record, Idx)));
4722
4723  case DeclarationName::CXXConversionFunctionName:
4724    return Context->DeclarationNames.getCXXConversionFunctionName(
4725                          Context->getCanonicalType(readType(F, Record, Idx)));
4726
4727  case DeclarationName::CXXOperatorName:
4728    return Context->DeclarationNames.getCXXOperatorName(
4729                                       (OverloadedOperatorKind)Record[Idx++]);
4730
4731  case DeclarationName::CXXLiteralOperatorName:
4732    return Context->DeclarationNames.getCXXLiteralOperatorName(
4733                                       GetIdentifierInfo(Record, Idx));
4734
4735  case DeclarationName::CXXUsingDirective:
4736    return DeclarationName::getUsingDirectiveName();
4737  }
4738
4739  // Required to silence GCC warning
4740  return DeclarationName();
4741}
4742
4743void ASTReader::ReadDeclarationNameLoc(Module &F,
4744                                       DeclarationNameLoc &DNLoc,
4745                                       DeclarationName Name,
4746                                      const RecordData &Record, unsigned &Idx) {
4747  switch (Name.getNameKind()) {
4748  case DeclarationName::CXXConstructorName:
4749  case DeclarationName::CXXDestructorName:
4750  case DeclarationName::CXXConversionFunctionName:
4751    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
4752    break;
4753
4754  case DeclarationName::CXXOperatorName:
4755    DNLoc.CXXOperatorName.BeginOpNameLoc
4756        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4757    DNLoc.CXXOperatorName.EndOpNameLoc
4758        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4759    break;
4760
4761  case DeclarationName::CXXLiteralOperatorName:
4762    DNLoc.CXXLiteralOperatorName.OpNameLoc
4763        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
4764    break;
4765
4766  case DeclarationName::Identifier:
4767  case DeclarationName::ObjCZeroArgSelector:
4768  case DeclarationName::ObjCOneArgSelector:
4769  case DeclarationName::ObjCMultiArgSelector:
4770  case DeclarationName::CXXUsingDirective:
4771    break;
4772  }
4773}
4774
4775void ASTReader::ReadDeclarationNameInfo(Module &F,
4776                                        DeclarationNameInfo &NameInfo,
4777                                      const RecordData &Record, unsigned &Idx) {
4778  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
4779  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
4780  DeclarationNameLoc DNLoc;
4781  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
4782  NameInfo.setInfo(DNLoc);
4783}
4784
4785void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info,
4786                                  const RecordData &Record, unsigned &Idx) {
4787  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
4788  unsigned NumTPLists = Record[Idx++];
4789  Info.NumTemplParamLists = NumTPLists;
4790  if (NumTPLists) {
4791    Info.TemplParamLists = new (*Context) TemplateParameterList*[NumTPLists];
4792    for (unsigned i=0; i != NumTPLists; ++i)
4793      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
4794  }
4795}
4796
4797TemplateName
4798ASTReader::ReadTemplateName(Module &F, const RecordData &Record,
4799                            unsigned &Idx) {
4800  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
4801  switch (Kind) {
4802  case TemplateName::Template:
4803      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
4804
4805  case TemplateName::OverloadedTemplate: {
4806    unsigned size = Record[Idx++];
4807    UnresolvedSet<8> Decls;
4808    while (size--)
4809      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
4810
4811    return Context->getOverloadedTemplateName(Decls.begin(), Decls.end());
4812  }
4813
4814  case TemplateName::QualifiedTemplate: {
4815    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4816    bool hasTemplKeyword = Record[Idx++];
4817    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
4818    return Context->getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
4819  }
4820
4821  case TemplateName::DependentTemplate: {
4822    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
4823    if (Record[Idx++])  // isIdentifier
4824      return Context->getDependentTemplateName(NNS,
4825                                               GetIdentifierInfo(Record, Idx));
4826    return Context->getDependentTemplateName(NNS,
4827                                         (OverloadedOperatorKind)Record[Idx++]);
4828  }
4829
4830  case TemplateName::SubstTemplateTemplateParm: {
4831    TemplateTemplateParmDecl *param
4832      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4833    if (!param) return TemplateName();
4834    TemplateName replacement = ReadTemplateName(F, Record, Idx);
4835    return Context->getSubstTemplateTemplateParm(param, replacement);
4836  }
4837
4838  case TemplateName::SubstTemplateTemplateParmPack: {
4839    TemplateTemplateParmDecl *Param
4840      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
4841    if (!Param)
4842      return TemplateName();
4843
4844    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
4845    if (ArgPack.getKind() != TemplateArgument::Pack)
4846      return TemplateName();
4847
4848    return Context->getSubstTemplateTemplateParmPack(Param, ArgPack);
4849  }
4850  }
4851
4852  assert(0 && "Unhandled template name kind!");
4853  return TemplateName();
4854}
4855
4856TemplateArgument
4857ASTReader::ReadTemplateArgument(Module &F,
4858                                const RecordData &Record, unsigned &Idx) {
4859  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
4860  switch (Kind) {
4861  case TemplateArgument::Null:
4862    return TemplateArgument();
4863  case TemplateArgument::Type:
4864    return TemplateArgument(readType(F, Record, Idx));
4865  case TemplateArgument::Declaration:
4866    return TemplateArgument(ReadDecl(F, Record, Idx));
4867  case TemplateArgument::Integral: {
4868    llvm::APSInt Value = ReadAPSInt(Record, Idx);
4869    QualType T = readType(F, Record, Idx);
4870    return TemplateArgument(Value, T);
4871  }
4872  case TemplateArgument::Template:
4873    return TemplateArgument(ReadTemplateName(F, Record, Idx));
4874  case TemplateArgument::TemplateExpansion: {
4875    TemplateName Name = ReadTemplateName(F, Record, Idx);
4876    llvm::Optional<unsigned> NumTemplateExpansions;
4877    if (unsigned NumExpansions = Record[Idx++])
4878      NumTemplateExpansions = NumExpansions - 1;
4879    return TemplateArgument(Name, NumTemplateExpansions);
4880  }
4881  case TemplateArgument::Expression:
4882    return TemplateArgument(ReadExpr(F));
4883  case TemplateArgument::Pack: {
4884    unsigned NumArgs = Record[Idx++];
4885    TemplateArgument *Args = new (*Context) TemplateArgument[NumArgs];
4886    for (unsigned I = 0; I != NumArgs; ++I)
4887      Args[I] = ReadTemplateArgument(F, Record, Idx);
4888    return TemplateArgument(Args, NumArgs);
4889  }
4890  }
4891
4892  assert(0 && "Unhandled template argument kind!");
4893  return TemplateArgument();
4894}
4895
4896TemplateParameterList *
4897ASTReader::ReadTemplateParameterList(Module &F,
4898                                     const RecordData &Record, unsigned &Idx) {
4899  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
4900  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
4901  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
4902
4903  unsigned NumParams = Record[Idx++];
4904  SmallVector<NamedDecl *, 16> Params;
4905  Params.reserve(NumParams);
4906  while (NumParams--)
4907    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
4908
4909  TemplateParameterList* TemplateParams =
4910    TemplateParameterList::Create(*Context, TemplateLoc, LAngleLoc,
4911                                  Params.data(), Params.size(), RAngleLoc);
4912  return TemplateParams;
4913}
4914
4915void
4916ASTReader::
4917ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
4918                         Module &F, const RecordData &Record,
4919                         unsigned &Idx) {
4920  unsigned NumTemplateArgs = Record[Idx++];
4921  TemplArgs.reserve(NumTemplateArgs);
4922  while (NumTemplateArgs--)
4923    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
4924}
4925
4926/// \brief Read a UnresolvedSet structure.
4927void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set,
4928                                  const RecordData &Record, unsigned &Idx) {
4929  unsigned NumDecls = Record[Idx++];
4930  while (NumDecls--) {
4931    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
4932    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
4933    Set.addDecl(D, AS);
4934  }
4935}
4936
4937CXXBaseSpecifier
4938ASTReader::ReadCXXBaseSpecifier(Module &F,
4939                                const RecordData &Record, unsigned &Idx) {
4940  bool isVirtual = static_cast<bool>(Record[Idx++]);
4941  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
4942  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
4943  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
4944  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
4945  SourceRange Range = ReadSourceRange(F, Record, Idx);
4946  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
4947  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
4948                          EllipsisLoc);
4949  Result.setInheritConstructors(inheritConstructors);
4950  return Result;
4951}
4952
4953std::pair<CXXCtorInitializer **, unsigned>
4954ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record,
4955                                   unsigned &Idx) {
4956  CXXCtorInitializer **CtorInitializers = 0;
4957  unsigned NumInitializers = Record[Idx++];
4958  if (NumInitializers) {
4959    ASTContext &C = *getContext();
4960
4961    CtorInitializers
4962        = new (C) CXXCtorInitializer*[NumInitializers];
4963    for (unsigned i=0; i != NumInitializers; ++i) {
4964      TypeSourceInfo *BaseClassInfo = 0;
4965      bool IsBaseVirtual = false;
4966      FieldDecl *Member = 0;
4967      IndirectFieldDecl *IndirectMember = 0;
4968      CXXConstructorDecl *Target = 0;
4969
4970      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
4971      switch (Type) {
4972       case CTOR_INITIALIZER_BASE:
4973        BaseClassInfo = GetTypeSourceInfo(F, Record, Idx);
4974        IsBaseVirtual = Record[Idx++];
4975        break;
4976
4977       case CTOR_INITIALIZER_DELEGATING:
4978        Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx);
4979        break;
4980
4981       case CTOR_INITIALIZER_MEMBER:
4982        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
4983        break;
4984
4985       case CTOR_INITIALIZER_INDIRECT_MEMBER:
4986        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
4987        break;
4988      }
4989
4990      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
4991      Expr *Init = ReadExpr(F);
4992      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
4993      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
4994      bool IsWritten = Record[Idx++];
4995      unsigned SourceOrderOrNumArrayIndices;
4996      SmallVector<VarDecl *, 8> Indices;
4997      if (IsWritten) {
4998        SourceOrderOrNumArrayIndices = Record[Idx++];
4999      } else {
5000        SourceOrderOrNumArrayIndices = Record[Idx++];
5001        Indices.reserve(SourceOrderOrNumArrayIndices);
5002        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
5003          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
5004      }
5005
5006      CXXCtorInitializer *BOMInit;
5007      if (Type == CTOR_INITIALIZER_BASE) {
5008        BOMInit = new (C) CXXCtorInitializer(C, BaseClassInfo, IsBaseVirtual,
5009                                             LParenLoc, Init, RParenLoc,
5010                                             MemberOrEllipsisLoc);
5011      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
5012        BOMInit = new (C) CXXCtorInitializer(C, MemberOrEllipsisLoc, LParenLoc,
5013                                             Target, Init, RParenLoc);
5014      } else if (IsWritten) {
5015        if (Member)
5016          BOMInit = new (C) CXXCtorInitializer(C, Member, MemberOrEllipsisLoc,
5017                                               LParenLoc, Init, RParenLoc);
5018        else
5019          BOMInit = new (C) CXXCtorInitializer(C, IndirectMember,
5020                                               MemberOrEllipsisLoc, LParenLoc,
5021                                               Init, RParenLoc);
5022      } else {
5023        BOMInit = CXXCtorInitializer::Create(C, Member, MemberOrEllipsisLoc,
5024                                             LParenLoc, Init, RParenLoc,
5025                                             Indices.data(), Indices.size());
5026      }
5027
5028      if (IsWritten)
5029        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
5030      CtorInitializers[i] = BOMInit;
5031    }
5032  }
5033
5034  return std::make_pair(CtorInitializers, NumInitializers);
5035}
5036
5037NestedNameSpecifier *
5038ASTReader::ReadNestedNameSpecifier(Module &F,
5039                                   const RecordData &Record, unsigned &Idx) {
5040  unsigned N = Record[Idx++];
5041  NestedNameSpecifier *NNS = 0, *Prev = 0;
5042  for (unsigned I = 0; I != N; ++I) {
5043    NestedNameSpecifier::SpecifierKind Kind
5044      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5045    switch (Kind) {
5046    case NestedNameSpecifier::Identifier: {
5047      IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
5048      NNS = NestedNameSpecifier::Create(*Context, Prev, II);
5049      break;
5050    }
5051
5052    case NestedNameSpecifier::Namespace: {
5053      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5054      NNS = NestedNameSpecifier::Create(*Context, Prev, NS);
5055      break;
5056    }
5057
5058    case NestedNameSpecifier::NamespaceAlias: {
5059      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5060      NNS = NestedNameSpecifier::Create(*Context, Prev, Alias);
5061      break;
5062    }
5063
5064    case NestedNameSpecifier::TypeSpec:
5065    case NestedNameSpecifier::TypeSpecWithTemplate: {
5066      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
5067      if (!T)
5068        return 0;
5069
5070      bool Template = Record[Idx++];
5071      NNS = NestedNameSpecifier::Create(*Context, Prev, Template, T);
5072      break;
5073    }
5074
5075    case NestedNameSpecifier::Global: {
5076      NNS = NestedNameSpecifier::GlobalSpecifier(*Context);
5077      // No associated value, and there can't be a prefix.
5078      break;
5079    }
5080    }
5081    Prev = NNS;
5082  }
5083  return NNS;
5084}
5085
5086NestedNameSpecifierLoc
5087ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record,
5088                                      unsigned &Idx) {
5089  unsigned N = Record[Idx++];
5090  NestedNameSpecifierLocBuilder Builder;
5091  for (unsigned I = 0; I != N; ++I) {
5092    NestedNameSpecifier::SpecifierKind Kind
5093      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
5094    switch (Kind) {
5095    case NestedNameSpecifier::Identifier: {
5096      IdentifierInfo *II = GetIdentifierInfo(Record, Idx);
5097      SourceRange Range = ReadSourceRange(F, Record, Idx);
5098      Builder.Extend(*Context, II, Range.getBegin(), Range.getEnd());
5099      break;
5100    }
5101
5102    case NestedNameSpecifier::Namespace: {
5103      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
5104      SourceRange Range = ReadSourceRange(F, Record, Idx);
5105      Builder.Extend(*Context, NS, Range.getBegin(), Range.getEnd());
5106      break;
5107    }
5108
5109    case NestedNameSpecifier::NamespaceAlias: {
5110      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
5111      SourceRange Range = ReadSourceRange(F, Record, Idx);
5112      Builder.Extend(*Context, Alias, Range.getBegin(), Range.getEnd());
5113      break;
5114    }
5115
5116    case NestedNameSpecifier::TypeSpec:
5117    case NestedNameSpecifier::TypeSpecWithTemplate: {
5118      bool Template = Record[Idx++];
5119      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
5120      if (!T)
5121        return NestedNameSpecifierLoc();
5122      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5123
5124      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
5125      Builder.Extend(*Context,
5126                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
5127                     T->getTypeLoc(), ColonColonLoc);
5128      break;
5129    }
5130
5131    case NestedNameSpecifier::Global: {
5132      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
5133      Builder.MakeGlobal(*Context, ColonColonLoc);
5134      break;
5135    }
5136    }
5137  }
5138
5139  return Builder.getWithLocInContext(*Context);
5140}
5141
5142SourceRange
5143ASTReader::ReadSourceRange(Module &F, const RecordData &Record,
5144                           unsigned &Idx) {
5145  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
5146  SourceLocation end = ReadSourceLocation(F, Record, Idx);
5147  return SourceRange(beg, end);
5148}
5149
5150/// \brief Read an integral value
5151llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
5152  unsigned BitWidth = Record[Idx++];
5153  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
5154  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
5155  Idx += NumWords;
5156  return Result;
5157}
5158
5159/// \brief Read a signed integral value
5160llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
5161  bool isUnsigned = Record[Idx++];
5162  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
5163}
5164
5165/// \brief Read a floating-point value
5166llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) {
5167  return llvm::APFloat(ReadAPInt(Record, Idx));
5168}
5169
5170// \brief Read a string
5171std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
5172  unsigned Len = Record[Idx++];
5173  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
5174  Idx += Len;
5175  return Result;
5176}
5177
5178VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
5179                                         unsigned &Idx) {
5180  unsigned Major = Record[Idx++];
5181  unsigned Minor = Record[Idx++];
5182  unsigned Subminor = Record[Idx++];
5183  if (Minor == 0)
5184    return VersionTuple(Major);
5185  if (Subminor == 0)
5186    return VersionTuple(Major, Minor - 1);
5187  return VersionTuple(Major, Minor - 1, Subminor - 1);
5188}
5189
5190CXXTemporary *ASTReader::ReadCXXTemporary(Module &F,
5191                                          const RecordData &Record,
5192                                          unsigned &Idx) {
5193  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
5194  return CXXTemporary::Create(*Context, Decl);
5195}
5196
5197DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
5198  return Diag(SourceLocation(), DiagID);
5199}
5200
5201DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
5202  return Diags.Report(Loc, DiagID);
5203}
5204
5205/// \brief Retrieve the identifier table associated with the
5206/// preprocessor.
5207IdentifierTable &ASTReader::getIdentifierTable() {
5208  assert(PP && "Forgot to set Preprocessor ?");
5209  return PP->getIdentifierTable();
5210}
5211
5212/// \brief Record that the given ID maps to the given switch-case
5213/// statement.
5214void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
5215  assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID");
5216  SwitchCaseStmts[ID] = SC;
5217}
5218
5219/// \brief Retrieve the switch-case statement with the given ID.
5220SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
5221  assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID");
5222  return SwitchCaseStmts[ID];
5223}
5224
5225void ASTReader::ClearSwitchCaseIDs() {
5226  SwitchCaseStmts.clear();
5227}
5228
5229void ASTReader::FinishedDeserializing() {
5230  assert(NumCurrentElementsDeserializing &&
5231         "FinishedDeserializing not paired with StartedDeserializing");
5232  if (NumCurrentElementsDeserializing == 1) {
5233    // If any identifiers with corresponding top-level declarations have
5234    // been loaded, load those declarations now.
5235    while (!PendingIdentifierInfos.empty()) {
5236      SetGloballyVisibleDecls(PendingIdentifierInfos.front().II,
5237                              PendingIdentifierInfos.front().DeclIDs, true);
5238      PendingIdentifierInfos.pop_front();
5239    }
5240
5241    // Ready to load previous declarations of Decls that were delayed.
5242    while (!PendingPreviousDecls.empty()) {
5243      loadAndAttachPreviousDecl(PendingPreviousDecls.front().first,
5244                                PendingPreviousDecls.front().second);
5245      PendingPreviousDecls.pop_front();
5246    }
5247
5248    // We are not in recursive loading, so it's safe to pass the "interesting"
5249    // decls to the consumer.
5250    if (Consumer)
5251      PassInterestingDeclsToConsumer();
5252
5253    assert(PendingForwardRefs.size() == 0 &&
5254           "Some forward refs did not get linked to the definition!");
5255  }
5256  --NumCurrentElementsDeserializing;
5257}
5258
5259ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
5260                     StringRef isysroot, bool DisableValidation,
5261                     bool DisableStatCache)
5262  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
5263    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
5264    Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context),
5265    Consumer(0), RelocatablePCH(false), isysroot(isysroot),
5266    DisableValidation(DisableValidation),
5267    DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0),
5268    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
5269    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
5270    TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
5271    NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0),
5272    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
5273    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
5274    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
5275    NumCXXBaseSpecifiersLoaded(0)
5276{
5277  SourceMgr.setExternalSLocEntrySource(this);
5278}
5279
5280ASTReader::ASTReader(SourceManager &SourceMgr, FileManager &FileMgr,
5281                     Diagnostic &Diags, StringRef isysroot,
5282                     bool DisableValidation, bool DisableStatCache)
5283  : DeserializationListener(0), SourceMgr(SourceMgr), FileMgr(FileMgr),
5284    Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0),
5285    RelocatablePCH(false), isysroot(isysroot),
5286    DisableValidation(DisableValidation), DisableStatCache(DisableStatCache),
5287    NumStatHits(0), NumStatMisses(0), NumSLocEntriesRead(0),
5288    TotalNumSLocEntries(0), NumStatementsRead(0),
5289    TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
5290    NumSelectorsRead(0), NumMethodPoolEntriesRead(0), NumMethodPoolMisses(0),
5291    TotalNumMethodPoolEntries(0), NumLexicalDeclContextsRead(0),
5292    TotalLexicalDeclContexts(0), NumVisibleDeclContextsRead(0),
5293    TotalVisibleDeclContexts(0), TotalModulesSizeInBits(0),
5294    NumCurrentElementsDeserializing(0), NumCXXBaseSpecifiersLoaded(0)
5295{
5296  SourceMgr.setExternalSLocEntrySource(this);
5297}
5298
5299ASTReader::~ASTReader() {
5300  // Delete all visible decl lookup tables
5301  for (DeclContextOffsetsMap::iterator I = DeclContextOffsets.begin(),
5302                                       E = DeclContextOffsets.end();
5303       I != E; ++I) {
5304    for (DeclContextInfos::iterator J = I->second.begin(), F = I->second.end();
5305         J != F; ++J) {
5306      if (J->NameLookupTableData)
5307        delete static_cast<ASTDeclContextNameLookupTable*>(
5308            J->NameLookupTableData);
5309    }
5310  }
5311  for (DeclContextVisibleUpdatesPending::iterator
5312           I = PendingVisibleUpdates.begin(),
5313           E = PendingVisibleUpdates.end();
5314       I != E; ++I) {
5315    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
5316                                             F = I->second.end();
5317         J != F; ++J)
5318      delete static_cast<ASTDeclContextNameLookupTable*>(*J);
5319  }
5320}
5321
5322Module::Module(ModuleKind Kind)
5323  : Kind(Kind), SizeInBits(0), LocalNumSLocEntries(0), SLocEntryBaseID(0),
5324    SLocEntryBaseOffset(0), SLocEntryOffsets(0),
5325    SLocFileOffsets(0), LocalNumIdentifiers(0),
5326    IdentifierOffsets(0), IdentifierTableData(0),
5327    IdentifierLookupTable(0), LocalNumMacroDefinitions(0),
5328    MacroDefinitionOffsets(0), LocalNumHeaderFileInfos(0),
5329    HeaderFileInfoTableData(0), HeaderFileInfoTable(0),
5330    LocalNumSelectors(0), SelectorOffsets(0),
5331    SelectorLookupTableData(0), SelectorLookupTable(0), LocalNumDecls(0),
5332    DeclOffsets(0), LocalNumCXXBaseSpecifiers(0), CXXBaseSpecifiersOffsets(0),
5333    LocalNumTypes(0), TypeOffsets(0), StatCache(0),
5334    NumPreallocatedPreprocessingEntities(0), NextInSource(0)
5335{}
5336
5337Module::~Module() {
5338  delete static_cast<ASTIdentifierLookupTable *>(IdentifierLookupTable);
5339  delete static_cast<HeaderFileInfoLookupTable *>(HeaderFileInfoTable);
5340  delete static_cast<ASTSelectorLookupTable *>(SelectorLookupTable);
5341}
5342
5343/// \brief Creates a new module and adds it to the list of known modules
5344Module &ModuleManager::addModule(StringRef FileName, ModuleKind Type) {
5345  Module *Prev = !size() ? 0 : &getLastModule();
5346  Module *Current = new Module(Type);
5347
5348  Current->FileName = FileName.str();
5349
5350  Chain.push_back(Current);
5351  Modules[FileName.str()] = Current;
5352
5353  if (Prev)
5354    Prev->NextInSource = Current;
5355  Current->Loaders.push_back(Prev);
5356
5357  return *Current;
5358}
5359
5360/// \brief Exports the list of loaded modules with their corresponding names
5361void ModuleManager::exportLookup(SmallVector<ModuleOffset, 16> &Target) {
5362  Target.reserve(size());
5363  for (llvm::StringMap<Module*>::const_iterator
5364           I = Modules.begin(), E = Modules.end();
5365       I != E; ++I) {
5366    Target.push_back(ModuleOffset(I->getValue()->SLocEntryBaseOffset,
5367                                   I->getKey()));
5368  }
5369  std::sort(Target.begin(), Target.end());
5370}
5371
5372ModuleManager::~ModuleManager() {
5373  for (unsigned i = 0, e = Chain.size(); i != e; ++i)
5374    delete Chain[e - i - 1];
5375}
5376