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