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