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