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