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