ASTReader.cpp revision 677e15ffee2ecc9c1c8f46fd77cab4b5afb59640 
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: return 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  }
3723}
3724
3725/// \brief Parse the record that corresponds to a LangOptions data
3726/// structure.
3727///
3728/// This routine parses the language options from the AST file and then gives
3729/// them to the AST listener if one is set.
3730///
3731/// \returns true if the listener deems the file unacceptable, false otherwise.
3732bool ASTReader::ParseLanguageOptions(const RecordData &Record,
3733                                     bool Complain,
3734                                     ASTReaderListener &Listener) {
3735  LangOptions LangOpts;
3736  unsigned Idx = 0;
3737#define LANGOPT(Name, Bits, Default, Description) \
3738  LangOpts.Name = Record[Idx++];
3739#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
3740  LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
3741#include "clang/Basic/LangOptions.def"
3742#define SANITIZER(NAME, ID) LangOpts.Sanitize.ID = Record[Idx++];
3743#include "clang/Basic/Sanitizers.def"
3744
3745  ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
3746  VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
3747  LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
3748
3749  unsigned Length = Record[Idx++];
3750  LangOpts.CurrentModule.assign(Record.begin() + Idx,
3751                                Record.begin() + Idx + Length);
3752
3753  Idx += Length;
3754
3755  // Comment options.
3756  for (unsigned N = Record[Idx++]; N; --N) {
3757    LangOpts.CommentOpts.BlockCommandNames.push_back(
3758      ReadString(Record, Idx));
3759  }
3760
3761  return Listener.ReadLanguageOptions(LangOpts, Complain);
3762}
3763
3764bool ASTReader::ParseTargetOptions(const RecordData &Record,
3765                                   bool Complain,
3766                                   ASTReaderListener &Listener) {
3767  unsigned Idx = 0;
3768  TargetOptions TargetOpts;
3769  TargetOpts.Triple = ReadString(Record, Idx);
3770  TargetOpts.CPU = ReadString(Record, Idx);
3771  TargetOpts.ABI = ReadString(Record, Idx);
3772  TargetOpts.CXXABI = ReadString(Record, Idx);
3773  TargetOpts.LinkerVersion = ReadString(Record, Idx);
3774  for (unsigned N = Record[Idx++]; N; --N) {
3775    TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
3776  }
3777  for (unsigned N = Record[Idx++]; N; --N) {
3778    TargetOpts.Features.push_back(ReadString(Record, Idx));
3779  }
3780
3781  return Listener.ReadTargetOptions(TargetOpts, Complain);
3782}
3783
3784bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
3785                                       ASTReaderListener &Listener) {
3786  DiagnosticOptions DiagOpts;
3787  unsigned Idx = 0;
3788#define DIAGOPT(Name, Bits, Default) DiagOpts.Name = Record[Idx++];
3789#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
3790  DiagOpts.set##Name(static_cast<Type>(Record[Idx++]));
3791#include "clang/Basic/DiagnosticOptions.def"
3792
3793  for (unsigned N = Record[Idx++]; N; --N) {
3794    DiagOpts.Warnings.push_back(ReadString(Record, Idx));
3795  }
3796
3797  return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
3798}
3799
3800bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
3801                                       ASTReaderListener &Listener) {
3802  FileSystemOptions FSOpts;
3803  unsigned Idx = 0;
3804  FSOpts.WorkingDir = ReadString(Record, Idx);
3805  return Listener.ReadFileSystemOptions(FSOpts, Complain);
3806}
3807
3808bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
3809                                         bool Complain,
3810                                         ASTReaderListener &Listener) {
3811  HeaderSearchOptions HSOpts;
3812  unsigned Idx = 0;
3813  HSOpts.Sysroot = ReadString(Record, Idx);
3814
3815  // Include entries.
3816  for (unsigned N = Record[Idx++]; N; --N) {
3817    std::string Path = ReadString(Record, Idx);
3818    frontend::IncludeDirGroup Group
3819      = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
3820    bool IsFramework = Record[Idx++];
3821    bool IgnoreSysRoot = Record[Idx++];
3822    HSOpts.UserEntries.push_back(
3823      HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot));
3824  }
3825
3826  // System header prefixes.
3827  for (unsigned N = Record[Idx++]; N; --N) {
3828    std::string Prefix = ReadString(Record, Idx);
3829    bool IsSystemHeader = Record[Idx++];
3830    HSOpts.SystemHeaderPrefixes.push_back(
3831      HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader));
3832  }
3833
3834  HSOpts.ResourceDir = ReadString(Record, Idx);
3835  HSOpts.ModuleCachePath = ReadString(Record, Idx);
3836  HSOpts.DisableModuleHash = Record[Idx++];
3837  HSOpts.UseBuiltinIncludes = Record[Idx++];
3838  HSOpts.UseStandardSystemIncludes = Record[Idx++];
3839  HSOpts.UseStandardCXXIncludes = Record[Idx++];
3840  HSOpts.UseLibcxx = Record[Idx++];
3841
3842  return Listener.ReadHeaderSearchOptions(HSOpts, Complain);
3843}
3844
3845bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
3846                                         bool Complain,
3847                                         ASTReaderListener &Listener,
3848                                         std::string &SuggestedPredefines) {
3849  PreprocessorOptions PPOpts;
3850  unsigned Idx = 0;
3851
3852  // Macro definitions/undefs
3853  for (unsigned N = Record[Idx++]; N; --N) {
3854    std::string Macro = ReadString(Record, Idx);
3855    bool IsUndef = Record[Idx++];
3856    PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
3857  }
3858
3859  // Includes
3860  for (unsigned N = Record[Idx++]; N; --N) {
3861    PPOpts.Includes.push_back(ReadString(Record, Idx));
3862  }
3863
3864  // Macro Includes
3865  for (unsigned N = Record[Idx++]; N; --N) {
3866    PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
3867  }
3868
3869  PPOpts.UsePredefines = Record[Idx++];
3870  PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
3871  PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
3872  PPOpts.ObjCXXARCStandardLibrary =
3873    static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
3874  SuggestedPredefines.clear();
3875  return Listener.ReadPreprocessorOptions(PPOpts, Complain,
3876                                          SuggestedPredefines);
3877}
3878
3879std::pair<ModuleFile *, unsigned>
3880ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
3881  GlobalPreprocessedEntityMapType::iterator
3882  I = GlobalPreprocessedEntityMap.find(GlobalIndex);
3883  assert(I != GlobalPreprocessedEntityMap.end() &&
3884         "Corrupted global preprocessed entity map");
3885  ModuleFile *M = I->second;
3886  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
3887  return std::make_pair(M, LocalIndex);
3888}
3889
3890std::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator>
3891ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
3892  if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
3893    return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
3894                                             Mod.NumPreprocessedEntities);
3895
3896  return std::make_pair(PreprocessingRecord::iterator(),
3897                        PreprocessingRecord::iterator());
3898}
3899
3900std::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator>
3901ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
3902  return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
3903                        ModuleDeclIterator(this, &Mod,
3904                                 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
3905}
3906
3907PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
3908  PreprocessedEntityID PPID = Index+1;
3909  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
3910  ModuleFile &M = *PPInfo.first;
3911  unsigned LocalIndex = PPInfo.second;
3912  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
3913
3914  if (!PP.getPreprocessingRecord()) {
3915    Error("no preprocessing record");
3916    return 0;
3917  }
3918
3919  SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
3920  M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
3921
3922  llvm::BitstreamEntry Entry =
3923    M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
3924  if (Entry.Kind != llvm::BitstreamEntry::Record)
3925    return 0;
3926
3927  // Read the record.
3928  SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
3929                    ReadSourceLocation(M, PPOffs.End));
3930  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
3931  StringRef Blob;
3932  RecordData Record;
3933  PreprocessorDetailRecordTypes RecType =
3934    (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
3935                                          Entry.ID, Record, &Blob);
3936  switch (RecType) {
3937  case PPD_MACRO_EXPANSION: {
3938    bool isBuiltin = Record[0];
3939    IdentifierInfo *Name = 0;
3940    MacroDefinition *Def = 0;
3941    if (isBuiltin)
3942      Name = getLocalIdentifier(M, Record[1]);
3943    else {
3944      PreprocessedEntityID
3945          GlobalID = getGlobalPreprocessedEntityID(M, Record[1]);
3946      Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1));
3947    }
3948
3949    MacroExpansion *ME;
3950    if (isBuiltin)
3951      ME = new (PPRec) MacroExpansion(Name, Range);
3952    else
3953      ME = new (PPRec) MacroExpansion(Def, Range);
3954
3955    return ME;
3956  }
3957
3958  case PPD_MACRO_DEFINITION: {
3959    // Decode the identifier info and then check again; if the macro is
3960    // still defined and associated with the identifier,
3961    IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
3962    MacroDefinition *MD
3963      = new (PPRec) MacroDefinition(II, Range);
3964
3965    if (DeserializationListener)
3966      DeserializationListener->MacroDefinitionRead(PPID, MD);
3967
3968    return MD;
3969  }
3970
3971  case PPD_INCLUSION_DIRECTIVE: {
3972    const char *FullFileNameStart = Blob.data() + Record[0];
3973    StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
3974    const FileEntry *File = 0;
3975    if (!FullFileName.empty())
3976      File = PP.getFileManager().getFile(FullFileName);
3977
3978    // FIXME: Stable encoding
3979    InclusionDirective::InclusionKind Kind
3980      = static_cast<InclusionDirective::InclusionKind>(Record[2]);
3981    InclusionDirective *ID
3982      = new (PPRec) InclusionDirective(PPRec, Kind,
3983                                       StringRef(Blob.data(), Record[0]),
3984                                       Record[1], Record[3],
3985                                       File,
3986                                       Range);
3987    return ID;
3988  }
3989  }
3990
3991  llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
3992}
3993
3994/// \brief \arg SLocMapI points at a chunk of a module that contains no
3995/// preprocessed entities or the entities it contains are not the ones we are
3996/// looking for. Find the next module that contains entities and return the ID
3997/// of the first entry.
3998PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
3999                       GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
4000  ++SLocMapI;
4001  for (GlobalSLocOffsetMapType::const_iterator
4002         EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
4003    ModuleFile &M = *SLocMapI->second;
4004    if (M.NumPreprocessedEntities)
4005      return M.BasePreprocessedEntityID;
4006  }
4007
4008  return getTotalNumPreprocessedEntities();
4009}
4010
4011namespace {
4012
4013template <unsigned PPEntityOffset::*PPLoc>
4014struct PPEntityComp {
4015  const ASTReader &Reader;
4016  ModuleFile &M;
4017
4018  PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
4019
4020  bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4021    SourceLocation LHS = getLoc(L);
4022    SourceLocation RHS = getLoc(R);
4023    return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4024  }
4025
4026  bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
4027    SourceLocation LHS = getLoc(L);
4028    return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4029  }
4030
4031  bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
4032    SourceLocation RHS = getLoc(R);
4033    return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4034  }
4035
4036  SourceLocation getLoc(const PPEntityOffset &PPE) const {
4037    return Reader.ReadSourceLocation(M, PPE.*PPLoc);
4038  }
4039};
4040
4041}
4042
4043/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc.
4044PreprocessedEntityID
4045ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const {
4046  if (SourceMgr.isLocalSourceLocation(BLoc))
4047    return getTotalNumPreprocessedEntities();
4048
4049  GlobalSLocOffsetMapType::const_iterator
4050    SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset -
4051                                        BLoc.getOffset() - 1);
4052  assert(SLocMapI != GlobalSLocOffsetMap.end() &&
4053         "Corrupted global sloc offset map");
4054
4055  if (SLocMapI->second->NumPreprocessedEntities == 0)
4056    return findNextPreprocessedEntity(SLocMapI);
4057
4058  ModuleFile &M = *SLocMapI->second;
4059  typedef const PPEntityOffset *pp_iterator;
4060  pp_iterator pp_begin = M.PreprocessedEntityOffsets;
4061  pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
4062
4063  size_t Count = M.NumPreprocessedEntities;
4064  size_t Half;
4065  pp_iterator First = pp_begin;
4066  pp_iterator PPI;
4067
4068  // Do a binary search manually instead of using std::lower_bound because
4069  // The end locations of entities may be unordered (when a macro expansion
4070  // is inside another macro argument), but for this case it is not important
4071  // whether we get the first macro expansion or its containing macro.
4072  while (Count > 0) {
4073    Half = Count/2;
4074    PPI = First;
4075    std::advance(PPI, Half);
4076    if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
4077                                            BLoc)){
4078      First = PPI;
4079      ++First;
4080      Count = Count - Half - 1;
4081    } else
4082      Count = Half;
4083  }
4084
4085  if (PPI == pp_end)
4086    return findNextPreprocessedEntity(SLocMapI);
4087
4088  return M.BasePreprocessedEntityID + (PPI - pp_begin);
4089}
4090
4091/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc.
4092PreprocessedEntityID
4093ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const {
4094  if (SourceMgr.isLocalSourceLocation(ELoc))
4095    return getTotalNumPreprocessedEntities();
4096
4097  GlobalSLocOffsetMapType::const_iterator
4098    SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset -
4099                                        ELoc.getOffset() - 1);
4100  assert(SLocMapI != GlobalSLocOffsetMap.end() &&
4101         "Corrupted global sloc offset map");
4102
4103  if (SLocMapI->second->NumPreprocessedEntities == 0)
4104    return findNextPreprocessedEntity(SLocMapI);
4105
4106  ModuleFile &M = *SLocMapI->second;
4107  typedef const PPEntityOffset *pp_iterator;
4108  pp_iterator pp_begin = M.PreprocessedEntityOffsets;
4109  pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
4110  pp_iterator PPI =
4111      std::upper_bound(pp_begin, pp_end, ELoc,
4112                       PPEntityComp<&PPEntityOffset::Begin>(*this, M));
4113
4114  if (PPI == pp_end)
4115    return findNextPreprocessedEntity(SLocMapI);
4116
4117  return M.BasePreprocessedEntityID + (PPI - pp_begin);
4118}
4119
4120/// \brief Returns a pair of [Begin, End) indices of preallocated
4121/// preprocessed entities that \arg Range encompasses.
4122std::pair<unsigned, unsigned>
4123    ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
4124  if (Range.isInvalid())
4125    return std::make_pair(0,0);
4126  assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
4127
4128  PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin());
4129  PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd());
4130  return std::make_pair(BeginID, EndID);
4131}
4132
4133/// \brief Optionally returns true or false if the preallocated preprocessed
4134/// entity with index \arg Index came from file \arg FID.
4135Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
4136                                                             FileID FID) {
4137  if (FID.isInvalid())
4138    return false;
4139
4140  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4141  ModuleFile &M = *PPInfo.first;
4142  unsigned LocalIndex = PPInfo.second;
4143  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4144
4145  SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
4146  if (Loc.isInvalid())
4147    return false;
4148
4149  if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
4150    return true;
4151  else
4152    return false;
4153}
4154
4155namespace {
4156  /// \brief Visitor used to search for information about a header file.
4157  class HeaderFileInfoVisitor {
4158    const FileEntry *FE;
4159
4160    Optional<HeaderFileInfo> HFI;
4161
4162  public:
4163    explicit HeaderFileInfoVisitor(const FileEntry *FE)
4164      : FE(FE) { }
4165
4166    static bool visit(ModuleFile &M, void *UserData) {
4167      HeaderFileInfoVisitor *This
4168        = static_cast<HeaderFileInfoVisitor *>(UserData);
4169
4170      HeaderFileInfoLookupTable *Table
4171        = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
4172      if (!Table)
4173        return false;
4174
4175      // Look in the on-disk hash table for an entry for this file name.
4176      HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE);
4177      if (Pos == Table->end())
4178        return false;
4179
4180      This->HFI = *Pos;
4181      return true;
4182    }
4183
4184    Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
4185  };
4186}
4187
4188HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
4189  HeaderFileInfoVisitor Visitor(FE);
4190  ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor);
4191  if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) {
4192    if (Listener)
4193      Listener->ReadHeaderFileInfo(*HFI, FE->getUID());
4194    return *HFI;
4195  }
4196
4197  return HeaderFileInfo();
4198}
4199
4200void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
4201  // FIXME: Make it work properly with modules.
4202  SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
4203  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
4204    ModuleFile &F = *(*I);
4205    unsigned Idx = 0;
4206    DiagStates.clear();
4207    assert(!Diag.DiagStates.empty());
4208    DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
4209    while (Idx < F.PragmaDiagMappings.size()) {
4210      SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
4211      unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
4212      if (DiagStateID != 0) {
4213        Diag.DiagStatePoints.push_back(
4214                    DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
4215                    FullSourceLoc(Loc, SourceMgr)));
4216        continue;
4217      }
4218
4219      assert(DiagStateID == 0);
4220      // A new DiagState was created here.
4221      Diag.DiagStates.push_back(*Diag.GetCurDiagState());
4222      DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
4223      DiagStates.push_back(NewState);
4224      Diag.DiagStatePoints.push_back(
4225          DiagnosticsEngine::DiagStatePoint(NewState,
4226                                            FullSourceLoc(Loc, SourceMgr)));
4227      while (1) {
4228        assert(Idx < F.PragmaDiagMappings.size() &&
4229               "Invalid data, didn't find '-1' marking end of diag/map pairs");
4230        if (Idx >= F.PragmaDiagMappings.size()) {
4231          break; // Something is messed up but at least avoid infinite loop in
4232                 // release build.
4233        }
4234        unsigned DiagID = F.PragmaDiagMappings[Idx++];
4235        if (DiagID == (unsigned)-1) {
4236          break; // no more diag/map pairs for this location.
4237        }
4238        diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++];
4239        DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc);
4240        Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo);
4241      }
4242    }
4243  }
4244}
4245
4246/// \brief Get the correct cursor and offset for loading a type.
4247ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
4248  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
4249  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
4250  ModuleFile *M = I->second;
4251  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
4252}
4253
4254/// \brief Read and return the type with the given index..
4255///
4256/// The index is the type ID, shifted and minus the number of predefs. This
4257/// routine actually reads the record corresponding to the type at the given
4258/// location. It is a helper routine for GetType, which deals with reading type
4259/// IDs.
4260QualType ASTReader::readTypeRecord(unsigned Index) {
4261  RecordLocation Loc = TypeCursorForIndex(Index);
4262  BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
4263
4264  // Keep track of where we are in the stream, then jump back there
4265  // after reading this type.
4266  SavedStreamPosition SavedPosition(DeclsCursor);
4267
4268  ReadingKindTracker ReadingKind(Read_Type, *this);
4269
4270  // Note that we are loading a type record.
4271  Deserializing AType(this);
4272
4273  unsigned Idx = 0;
4274  DeclsCursor.JumpToBit(Loc.Offset);
4275  RecordData Record;
4276  unsigned Code = DeclsCursor.ReadCode();
4277  switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
4278  case TYPE_EXT_QUAL: {
4279    if (Record.size() != 2) {
4280      Error("Incorrect encoding of extended qualifier type");
4281      return QualType();
4282    }
4283    QualType Base = readType(*Loc.F, Record, Idx);
4284    Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
4285    return Context.getQualifiedType(Base, Quals);
4286  }
4287
4288  case TYPE_COMPLEX: {
4289    if (Record.size() != 1) {
4290      Error("Incorrect encoding of complex type");
4291      return QualType();
4292    }
4293    QualType ElemType = readType(*Loc.F, Record, Idx);
4294    return Context.getComplexType(ElemType);
4295  }
4296
4297  case TYPE_POINTER: {
4298    if (Record.size() != 1) {
4299      Error("Incorrect encoding of pointer type");
4300      return QualType();
4301    }
4302    QualType PointeeType = readType(*Loc.F, Record, Idx);
4303    return Context.getPointerType(PointeeType);
4304  }
4305
4306  case TYPE_BLOCK_POINTER: {
4307    if (Record.size() != 1) {
4308      Error("Incorrect encoding of block pointer type");
4309      return QualType();
4310    }
4311    QualType PointeeType = readType(*Loc.F, Record, Idx);
4312    return Context.getBlockPointerType(PointeeType);
4313  }
4314
4315  case TYPE_LVALUE_REFERENCE: {
4316    if (Record.size() != 2) {
4317      Error("Incorrect encoding of lvalue reference type");
4318      return QualType();
4319    }
4320    QualType PointeeType = readType(*Loc.F, Record, Idx);
4321    return Context.getLValueReferenceType(PointeeType, Record[1]);
4322  }
4323
4324  case TYPE_RVALUE_REFERENCE: {
4325    if (Record.size() != 1) {
4326      Error("Incorrect encoding of rvalue reference type");
4327      return QualType();
4328    }
4329    QualType PointeeType = readType(*Loc.F, Record, Idx);
4330    return Context.getRValueReferenceType(PointeeType);
4331  }
4332
4333  case TYPE_MEMBER_POINTER: {
4334    if (Record.size() != 2) {
4335      Error("Incorrect encoding of member pointer type");
4336      return QualType();
4337    }
4338    QualType PointeeType = readType(*Loc.F, Record, Idx);
4339    QualType ClassType = readType(*Loc.F, Record, Idx);
4340    if (PointeeType.isNull() || ClassType.isNull())
4341      return QualType();
4342
4343    return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
4344  }
4345
4346  case TYPE_CONSTANT_ARRAY: {
4347    QualType ElementType = readType(*Loc.F, Record, Idx);
4348    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
4349    unsigned IndexTypeQuals = Record[2];
4350    unsigned Idx = 3;
4351    llvm::APInt Size = ReadAPInt(Record, Idx);
4352    return Context.getConstantArrayType(ElementType, Size,
4353                                         ASM, IndexTypeQuals);
4354  }
4355
4356  case TYPE_INCOMPLETE_ARRAY: {
4357    QualType ElementType = readType(*Loc.F, Record, Idx);
4358    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
4359    unsigned IndexTypeQuals = Record[2];
4360    return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
4361  }
4362
4363  case TYPE_VARIABLE_ARRAY: {
4364    QualType ElementType = readType(*Loc.F, Record, Idx);
4365    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
4366    unsigned IndexTypeQuals = Record[2];
4367    SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
4368    SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
4369    return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
4370                                         ASM, IndexTypeQuals,
4371                                         SourceRange(LBLoc, RBLoc));
4372  }
4373
4374  case TYPE_VECTOR: {
4375    if (Record.size() != 3) {
4376      Error("incorrect encoding of vector type in AST file");
4377      return QualType();
4378    }
4379
4380    QualType ElementType = readType(*Loc.F, Record, Idx);
4381    unsigned NumElements = Record[1];
4382    unsigned VecKind = Record[2];
4383    return Context.getVectorType(ElementType, NumElements,
4384                                  (VectorType::VectorKind)VecKind);
4385  }
4386
4387  case TYPE_EXT_VECTOR: {
4388    if (Record.size() != 3) {
4389      Error("incorrect encoding of extended vector type in AST file");
4390      return QualType();
4391    }
4392
4393    QualType ElementType = readType(*Loc.F, Record, Idx);
4394    unsigned NumElements = Record[1];
4395    return Context.getExtVectorType(ElementType, NumElements);
4396  }
4397
4398  case TYPE_FUNCTION_NO_PROTO: {
4399    if (Record.size() != 6) {
4400      Error("incorrect encoding of no-proto function type");
4401      return QualType();
4402    }
4403    QualType ResultType = readType(*Loc.F, Record, Idx);
4404    FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
4405                               (CallingConv)Record[4], Record[5]);
4406    return Context.getFunctionNoProtoType(ResultType, Info);
4407  }
4408
4409  case TYPE_FUNCTION_PROTO: {
4410    QualType ResultType = readType(*Loc.F, Record, Idx);
4411
4412    FunctionProtoType::ExtProtoInfo EPI;
4413    EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
4414                                        /*hasregparm*/ Record[2],
4415                                        /*regparm*/ Record[3],
4416                                        static_cast<CallingConv>(Record[4]),
4417                                        /*produces*/ Record[5]);
4418
4419    unsigned Idx = 6;
4420    unsigned NumParams = Record[Idx++];
4421    SmallVector<QualType, 16> ParamTypes;
4422    for (unsigned I = 0; I != NumParams; ++I)
4423      ParamTypes.push_back(readType(*Loc.F, Record, Idx));
4424
4425    EPI.Variadic = Record[Idx++];
4426    EPI.HasTrailingReturn = Record[Idx++];
4427    EPI.TypeQuals = Record[Idx++];
4428    EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
4429    ExceptionSpecificationType EST =
4430        static_cast<ExceptionSpecificationType>(Record[Idx++]);
4431    EPI.ExceptionSpecType = EST;
4432    SmallVector<QualType, 2> Exceptions;
4433    if (EST == EST_Dynamic) {
4434      EPI.NumExceptions = Record[Idx++];
4435      for (unsigned I = 0; I != EPI.NumExceptions; ++I)
4436        Exceptions.push_back(readType(*Loc.F, Record, Idx));
4437      EPI.Exceptions = Exceptions.data();
4438    } else if (EST == EST_ComputedNoexcept) {
4439      EPI.NoexceptExpr = ReadExpr(*Loc.F);
4440    } else if (EST == EST_Uninstantiated) {
4441      EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx);
4442      EPI.ExceptionSpecTemplate = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx);
4443    } else if (EST == EST_Unevaluated) {
4444      EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx);
4445    }
4446    return Context.getFunctionType(ResultType, ParamTypes, EPI);
4447  }
4448
4449  case TYPE_UNRESOLVED_USING: {
4450    unsigned Idx = 0;
4451    return Context.getTypeDeclType(
4452                  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
4453  }
4454
4455  case TYPE_TYPEDEF: {
4456    if (Record.size() != 2) {
4457      Error("incorrect encoding of typedef type");
4458      return QualType();
4459    }
4460    unsigned Idx = 0;
4461    TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
4462    QualType Canonical = readType(*Loc.F, Record, Idx);
4463    if (!Canonical.isNull())
4464      Canonical = Context.getCanonicalType(Canonical);
4465    return Context.getTypedefType(Decl, Canonical);
4466  }
4467
4468  case TYPE_TYPEOF_EXPR:
4469    return Context.getTypeOfExprType(ReadExpr(*Loc.F));
4470
4471  case TYPE_TYPEOF: {
4472    if (Record.size() != 1) {
4473      Error("incorrect encoding of typeof(type) in AST file");
4474      return QualType();
4475    }
4476    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
4477    return Context.getTypeOfType(UnderlyingType);
4478  }
4479
4480  case TYPE_DECLTYPE: {
4481    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
4482    return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
4483  }
4484
4485  case TYPE_UNARY_TRANSFORM: {
4486    QualType BaseType = readType(*Loc.F, Record, Idx);
4487    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
4488    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
4489    return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
4490  }
4491
4492  case TYPE_AUTO:
4493    return Context.getAutoType(readType(*Loc.F, Record, Idx));
4494
4495  case TYPE_RECORD: {
4496    if (Record.size() != 2) {
4497      Error("incorrect encoding of record type");
4498      return QualType();
4499    }
4500    unsigned Idx = 0;
4501    bool IsDependent = Record[Idx++];
4502    RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
4503    RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
4504    QualType T = Context.getRecordType(RD);
4505    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
4506    return T;
4507  }
4508
4509  case TYPE_ENUM: {
4510    if (Record.size() != 2) {
4511      Error("incorrect encoding of enum type");
4512      return QualType();
4513    }
4514    unsigned Idx = 0;
4515    bool IsDependent = Record[Idx++];
4516    QualType T
4517      = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
4518    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
4519    return T;
4520  }
4521
4522  case TYPE_ATTRIBUTED: {
4523    if (Record.size() != 3) {
4524      Error("incorrect encoding of attributed type");
4525      return QualType();
4526    }
4527    QualType modifiedType = readType(*Loc.F, Record, Idx);
4528    QualType equivalentType = readType(*Loc.F, Record, Idx);
4529    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
4530    return Context.getAttributedType(kind, modifiedType, equivalentType);
4531  }
4532
4533  case TYPE_PAREN: {
4534    if (Record.size() != 1) {
4535      Error("incorrect encoding of paren type");
4536      return QualType();
4537    }
4538    QualType InnerType = readType(*Loc.F, Record, Idx);
4539    return Context.getParenType(InnerType);
4540  }
4541
4542  case TYPE_PACK_EXPANSION: {
4543    if (Record.size() != 2) {
4544      Error("incorrect encoding of pack expansion type");
4545      return QualType();
4546    }
4547    QualType Pattern = readType(*Loc.F, Record, Idx);
4548    if (Pattern.isNull())
4549      return QualType();
4550    Optional<unsigned> NumExpansions;
4551    if (Record[1])
4552      NumExpansions = Record[1] - 1;
4553    return Context.getPackExpansionType(Pattern, NumExpansions);
4554  }
4555
4556  case TYPE_ELABORATED: {
4557    unsigned Idx = 0;
4558    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
4559    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
4560    QualType NamedType = readType(*Loc.F, Record, Idx);
4561    return Context.getElaboratedType(Keyword, NNS, NamedType);
4562  }
4563
4564  case TYPE_OBJC_INTERFACE: {
4565    unsigned Idx = 0;
4566    ObjCInterfaceDecl *ItfD
4567      = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
4568    return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
4569  }
4570
4571  case TYPE_OBJC_OBJECT: {
4572    unsigned Idx = 0;
4573    QualType Base = readType(*Loc.F, Record, Idx);
4574    unsigned NumProtos = Record[Idx++];
4575    SmallVector<ObjCProtocolDecl*, 4> Protos;
4576    for (unsigned I = 0; I != NumProtos; ++I)
4577      Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
4578    return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
4579  }
4580
4581  case TYPE_OBJC_OBJECT_POINTER: {
4582    unsigned Idx = 0;
4583    QualType Pointee = readType(*Loc.F, Record, Idx);
4584    return Context.getObjCObjectPointerType(Pointee);
4585  }
4586
4587  case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
4588    unsigned Idx = 0;
4589    QualType Parm = readType(*Loc.F, Record, Idx);
4590    QualType Replacement = readType(*Loc.F, Record, Idx);
4591    return
4592      Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm),
4593                                            Replacement);
4594  }
4595
4596  case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
4597    unsigned Idx = 0;
4598    QualType Parm = readType(*Loc.F, Record, Idx);
4599    TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
4600    return Context.getSubstTemplateTypeParmPackType(
4601                                               cast<TemplateTypeParmType>(Parm),
4602                                                     ArgPack);
4603  }
4604
4605  case TYPE_INJECTED_CLASS_NAME: {
4606    CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
4607    QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
4608    // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
4609    // for AST reading, too much interdependencies.
4610    return
4611      QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0);
4612  }
4613
4614  case TYPE_TEMPLATE_TYPE_PARM: {
4615    unsigned Idx = 0;
4616    unsigned Depth = Record[Idx++];
4617    unsigned Index = Record[Idx++];
4618    bool Pack = Record[Idx++];
4619    TemplateTypeParmDecl *D
4620      = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
4621    return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
4622  }
4623
4624  case TYPE_DEPENDENT_NAME: {
4625    unsigned Idx = 0;
4626    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
4627    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
4628    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
4629    QualType Canon = readType(*Loc.F, Record, Idx);
4630    if (!Canon.isNull())
4631      Canon = Context.getCanonicalType(Canon);
4632    return Context.getDependentNameType(Keyword, NNS, Name, Canon);
4633  }
4634
4635  case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
4636    unsigned Idx = 0;
4637    ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
4638    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
4639    const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
4640    unsigned NumArgs = Record[Idx++];
4641    SmallVector<TemplateArgument, 8> Args;
4642    Args.reserve(NumArgs);
4643    while (NumArgs--)
4644      Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
4645    return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
4646                                                      Args.size(), Args.data());
4647  }
4648
4649  case TYPE_DEPENDENT_SIZED_ARRAY: {
4650    unsigned Idx = 0;
4651
4652    // ArrayType
4653    QualType ElementType = readType(*Loc.F, Record, Idx);
4654    ArrayType::ArraySizeModifier ASM
4655      = (ArrayType::ArraySizeModifier)Record[Idx++];
4656    unsigned IndexTypeQuals = Record[Idx++];
4657
4658    // DependentSizedArrayType
4659    Expr *NumElts = ReadExpr(*Loc.F);
4660    SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
4661
4662    return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
4663                                               IndexTypeQuals, Brackets);
4664  }
4665
4666  case TYPE_TEMPLATE_SPECIALIZATION: {
4667    unsigned Idx = 0;
4668    bool IsDependent = Record[Idx++];
4669    TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
4670    SmallVector<TemplateArgument, 8> Args;
4671    ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
4672    QualType Underlying = readType(*Loc.F, Record, Idx);
4673    QualType T;
4674    if (Underlying.isNull())
4675      T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
4676                                                          Args.size());
4677    else
4678      T = Context.getTemplateSpecializationType(Name, Args.data(),
4679                                                 Args.size(), Underlying);
4680    const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
4681    return T;
4682  }
4683
4684  case TYPE_ATOMIC: {
4685    if (Record.size() != 1) {
4686      Error("Incorrect encoding of atomic type");
4687      return QualType();
4688    }
4689    QualType ValueType = readType(*Loc.F, Record, Idx);
4690    return Context.getAtomicType(ValueType);
4691  }
4692  }
4693  llvm_unreachable("Invalid TypeCode!");
4694}
4695
4696class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
4697  ASTReader &Reader;
4698  ModuleFile &F;
4699  const ASTReader::RecordData &Record;
4700  unsigned &Idx;
4701
4702  SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
4703                                    unsigned &I) {
4704    return Reader.ReadSourceLocation(F, R, I);
4705  }
4706
4707  template<typename T>
4708  T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
4709    return Reader.ReadDeclAs<T>(F, Record, Idx);
4710  }
4711
4712public:
4713  TypeLocReader(ASTReader &Reader, ModuleFile &F,
4714                const ASTReader::RecordData &Record, unsigned &Idx)
4715    : Reader(Reader), F(F), Record(Record), Idx(Idx)
4716  { }
4717
4718  // We want compile-time assurance that we've enumerated all of
4719  // these, so unfortunately we have to declare them first, then
4720  // define them out-of-line.
4721#define ABSTRACT_TYPELOC(CLASS, PARENT)
4722#define TYPELOC(CLASS, PARENT) \
4723  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
4724#include "clang/AST/TypeLocNodes.def"
4725
4726  void VisitFunctionTypeLoc(FunctionTypeLoc);
4727  void VisitArrayTypeLoc(ArrayTypeLoc);
4728};
4729
4730void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
4731  // nothing to do
4732}
4733void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
4734  TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
4735  if (TL.needsExtraLocalData()) {
4736    TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
4737    TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
4738    TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
4739    TL.setModeAttr(Record[Idx++]);
4740  }
4741}
4742void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
4743  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4744}
4745void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
4746  TL.setStarLoc(ReadSourceLocation(Record, Idx));
4747}
4748void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
4749  TL.setCaretLoc(ReadSourceLocation(Record, Idx));
4750}
4751void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
4752  TL.setAmpLoc(ReadSourceLocation(Record, Idx));
4753}
4754void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
4755  TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
4756}
4757void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
4758  TL.setStarLoc(ReadSourceLocation(Record, Idx));
4759  TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4760}
4761void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
4762  TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
4763  TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
4764  if (Record[Idx++])
4765    TL.setSizeExpr(Reader.ReadExpr(F));
4766  else
4767    TL.setSizeExpr(0);
4768}
4769void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
4770  VisitArrayTypeLoc(TL);
4771}
4772void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
4773  VisitArrayTypeLoc(TL);
4774}
4775void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
4776  VisitArrayTypeLoc(TL);
4777}
4778void TypeLocReader::VisitDependentSizedArrayTypeLoc(
4779                                            DependentSizedArrayTypeLoc TL) {
4780  VisitArrayTypeLoc(TL);
4781}
4782void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
4783                                        DependentSizedExtVectorTypeLoc TL) {
4784  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4785}
4786void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
4787  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4788}
4789void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
4790  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4791}
4792void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
4793  TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
4794  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4795  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4796  TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
4797  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) {
4798    TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
4799  }
4800}
4801void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
4802  VisitFunctionTypeLoc(TL);
4803}
4804void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
4805  VisitFunctionTypeLoc(TL);
4806}
4807void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
4808  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4809}
4810void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
4811  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4812}
4813void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
4814  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
4815  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4816  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4817}
4818void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
4819  TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
4820  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4821  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4822  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4823}
4824void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
4825  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4826}
4827void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
4828  TL.setKWLoc(ReadSourceLocation(Record, Idx));
4829  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4830  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4831  TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
4832}
4833void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
4834  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4835}
4836void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
4837  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4838}
4839void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
4840  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4841}
4842void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
4843  TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
4844  if (TL.hasAttrOperand()) {
4845    SourceRange range;
4846    range.setBegin(ReadSourceLocation(Record, Idx));
4847    range.setEnd(ReadSourceLocation(Record, Idx));
4848    TL.setAttrOperandParensRange(range);
4849  }
4850  if (TL.hasAttrExprOperand()) {
4851    if (Record[Idx++])
4852      TL.setAttrExprOperand(Reader.ReadExpr(F));
4853    else
4854      TL.setAttrExprOperand(0);
4855  } else if (TL.hasAttrEnumOperand())
4856    TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
4857}
4858void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
4859  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4860}
4861void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
4862                                            SubstTemplateTypeParmTypeLoc TL) {
4863  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4864}
4865void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
4866                                          SubstTemplateTypeParmPackTypeLoc TL) {
4867  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4868}
4869void TypeLocReader::VisitTemplateSpecializationTypeLoc(
4870                                           TemplateSpecializationTypeLoc TL) {
4871  TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
4872  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
4873  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4874  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4875  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
4876    TL.setArgLocInfo(i,
4877        Reader.GetTemplateArgumentLocInfo(F,
4878                                          TL.getTypePtr()->getArg(i).getKind(),
4879                                          Record, Idx));
4880}
4881void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
4882  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4883  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4884}
4885void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
4886  TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
4887  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
4888}
4889void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
4890  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4891}
4892void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
4893  TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
4894  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
4895  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4896}
4897void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
4898       DependentTemplateSpecializationTypeLoc TL) {
4899  TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
4900  TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
4901  TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
4902  TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
4903  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4904  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4905  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
4906    TL.setArgLocInfo(I,
4907        Reader.GetTemplateArgumentLocInfo(F,
4908                                          TL.getTypePtr()->getArg(I).getKind(),
4909                                          Record, Idx));
4910}
4911void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
4912  TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
4913}
4914void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
4915  TL.setNameLoc(ReadSourceLocation(Record, Idx));
4916}
4917void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
4918  TL.setHasBaseTypeAsWritten(Record[Idx++]);
4919  TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
4920  TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
4921  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
4922    TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
4923}
4924void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
4925  TL.setStarLoc(ReadSourceLocation(Record, Idx));
4926}
4927void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
4928  TL.setKWLoc(ReadSourceLocation(Record, Idx));
4929  TL.setLParenLoc(ReadSourceLocation(Record, Idx));
4930  TL.setRParenLoc(ReadSourceLocation(Record, Idx));
4931}
4932
4933TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
4934                                             const RecordData &Record,
4935                                             unsigned &Idx) {
4936  QualType InfoTy = readType(F, Record, Idx);
4937  if (InfoTy.isNull())
4938    return 0;
4939
4940  TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
4941  TypeLocReader TLR(*this, F, Record, Idx);
4942  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
4943    TLR.Visit(TL);
4944  return TInfo;
4945}
4946
4947QualType ASTReader::GetType(TypeID ID) {
4948  unsigned FastQuals = ID & Qualifiers::FastMask;
4949  unsigned Index = ID >> Qualifiers::FastWidth;
4950
4951  if (Index < NUM_PREDEF_TYPE_IDS) {
4952    QualType T;
4953    switch ((PredefinedTypeIDs)Index) {
4954    case PREDEF_TYPE_NULL_ID: return QualType();
4955    case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break;
4956    case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break;
4957
4958    case PREDEF_TYPE_CHAR_U_ID:
4959    case PREDEF_TYPE_CHAR_S_ID:
4960      // FIXME: Check that the signedness of CharTy is correct!
4961      T = Context.CharTy;
4962      break;
4963
4964    case PREDEF_TYPE_UCHAR_ID:      T = Context.UnsignedCharTy;     break;
4965    case PREDEF_TYPE_USHORT_ID:     T = Context.UnsignedShortTy;    break;
4966    case PREDEF_TYPE_UINT_ID:       T = Context.UnsignedIntTy;      break;
4967    case PREDEF_TYPE_ULONG_ID:      T = Context.UnsignedLongTy;     break;
4968    case PREDEF_TYPE_ULONGLONG_ID:  T = Context.UnsignedLongLongTy; break;
4969    case PREDEF_TYPE_UINT128_ID:    T = Context.UnsignedInt128Ty;   break;
4970    case PREDEF_TYPE_SCHAR_ID:      T = Context.SignedCharTy;       break;
4971    case PREDEF_TYPE_WCHAR_ID:      T = Context.WCharTy;            break;
4972    case PREDEF_TYPE_SHORT_ID:      T = Context.ShortTy;            break;
4973    case PREDEF_TYPE_INT_ID:        T = Context.IntTy;              break;
4974    case PREDEF_TYPE_LONG_ID:       T = Context.LongTy;             break;
4975    case PREDEF_TYPE_LONGLONG_ID:   T = Context.LongLongTy;         break;
4976    case PREDEF_TYPE_INT128_ID:     T = Context.Int128Ty;           break;
4977    case PREDEF_TYPE_HALF_ID:       T = Context.HalfTy;             break;
4978    case PREDEF_TYPE_FLOAT_ID:      T = Context.FloatTy;            break;
4979    case PREDEF_TYPE_DOUBLE_ID:     T = Context.DoubleTy;           break;
4980    case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy;       break;
4981    case PREDEF_TYPE_OVERLOAD_ID:   T = Context.OverloadTy;         break;
4982    case PREDEF_TYPE_BOUND_MEMBER:  T = Context.BoundMemberTy;      break;
4983    case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy;     break;
4984    case PREDEF_TYPE_DEPENDENT_ID:  T = Context.DependentTy;        break;
4985    case PREDEF_TYPE_UNKNOWN_ANY:   T = Context.UnknownAnyTy;       break;
4986    case PREDEF_TYPE_NULLPTR_ID:    T = Context.NullPtrTy;          break;
4987    case PREDEF_TYPE_CHAR16_ID:     T = Context.Char16Ty;           break;
4988    case PREDEF_TYPE_CHAR32_ID:     T = Context.Char32Ty;           break;
4989    case PREDEF_TYPE_OBJC_ID:       T = Context.ObjCBuiltinIdTy;    break;
4990    case PREDEF_TYPE_OBJC_CLASS:    T = Context.ObjCBuiltinClassTy; break;
4991    case PREDEF_TYPE_OBJC_SEL:      T = Context.ObjCBuiltinSelTy;   break;
4992    case PREDEF_TYPE_IMAGE1D_ID:    T = Context.OCLImage1dTy;       break;
4993    case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break;
4994    case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break;
4995    case PREDEF_TYPE_IMAGE2D_ID:    T = Context.OCLImage2dTy;       break;
4996    case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break;
4997    case PREDEF_TYPE_IMAGE3D_ID:    T = Context.OCLImage3dTy;       break;
4998    case PREDEF_TYPE_SAMPLER_ID:    T = Context.OCLSamplerTy;       break;
4999    case PREDEF_TYPE_EVENT_ID:      T = Context.OCLEventTy;         break;
5000    case PREDEF_TYPE_AUTO_DEDUCT:   T = Context.getAutoDeductType(); break;
5001
5002    case PREDEF_TYPE_AUTO_RREF_DEDUCT:
5003      T = Context.getAutoRRefDeductType();
5004      break;
5005
5006    case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
5007      T = Context.ARCUnbridgedCastTy;
5008      break;
5009
5010    case PREDEF_TYPE_VA_LIST_TAG:
5011      T = Context.getVaListTagType();
5012      break;
5013
5014    case PREDEF_TYPE_BUILTIN_FN:
5015      T = Context.BuiltinFnTy;
5016      break;
5017    }
5018
5019    assert(!T.isNull() && "Unknown predefined type");
5020    return T.withFastQualifiers(FastQuals);
5021  }
5022
5023  Index -= NUM_PREDEF_TYPE_IDS;
5024  assert(Index < TypesLoaded.size() && "Type index out-of-range");
5025  if (TypesLoaded[Index].isNull()) {
5026    TypesLoaded[Index] = readTypeRecord(Index);
5027    if (TypesLoaded[Index].isNull())
5028      return QualType();
5029
5030    TypesLoaded[Index]->setFromAST();
5031    if (DeserializationListener)
5032      DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
5033                                        TypesLoaded[Index]);
5034  }
5035
5036  return TypesLoaded[Index].withFastQualifiers(FastQuals);
5037}
5038
5039QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
5040  return GetType(getGlobalTypeID(F, LocalID));
5041}
5042
5043serialization::TypeID
5044ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
5045  unsigned FastQuals = LocalID & Qualifiers::FastMask;
5046  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
5047
5048  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
5049    return LocalID;
5050
5051  ContinuousRangeMap<uint32_t, int, 2>::iterator I
5052    = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
5053  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
5054
5055  unsigned GlobalIndex = LocalIndex + I->second;
5056  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
5057}
5058
5059TemplateArgumentLocInfo
5060ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
5061                                      TemplateArgument::ArgKind Kind,
5062                                      const RecordData &Record,
5063                                      unsigned &Index) {
5064  switch (Kind) {
5065  case TemplateArgument::Expression:
5066    return ReadExpr(F);
5067  case TemplateArgument::Type:
5068    return GetTypeSourceInfo(F, Record, Index);
5069  case TemplateArgument::Template: {
5070    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
5071                                                                     Index);
5072    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
5073    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
5074                                   SourceLocation());
5075  }
5076  case TemplateArgument::TemplateExpansion: {
5077    NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
5078                                                                     Index);
5079    SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
5080    SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
5081    return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
5082                                   EllipsisLoc);
5083  }
5084  case TemplateArgument::Null:
5085  case TemplateArgument::Integral:
5086  case TemplateArgument::Declaration:
5087  case TemplateArgument::NullPtr:
5088  case TemplateArgument::Pack:
5089    // FIXME: Is this right?
5090    return TemplateArgumentLocInfo();
5091  }
5092  llvm_unreachable("unexpected template argument loc");
5093}
5094
5095TemplateArgumentLoc
5096ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
5097                                   const RecordData &Record, unsigned &Index) {
5098  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
5099
5100  if (Arg.getKind() == TemplateArgument::Expression) {
5101    if (Record[Index++]) // bool InfoHasSameExpr.
5102      return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
5103  }
5104  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
5105                                                             Record, Index));
5106}
5107
5108Decl *ASTReader::GetExternalDecl(uint32_t ID) {
5109  return GetDecl(ID);
5110}
5111
5112uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record,
5113                                          unsigned &Idx){
5114  if (Idx >= Record.size())
5115    return 0;
5116
5117  unsigned LocalID = Record[Idx++];
5118  return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
5119}
5120
5121CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
5122  RecordLocation Loc = getLocalBitOffset(Offset);
5123  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
5124  SavedStreamPosition SavedPosition(Cursor);
5125  Cursor.JumpToBit(Loc.Offset);
5126  ReadingKindTracker ReadingKind(Read_Decl, *this);
5127  RecordData Record;
5128  unsigned Code = Cursor.ReadCode();
5129  unsigned RecCode = Cursor.readRecord(Code, Record);
5130  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
5131    Error("Malformed AST file: missing C++ base specifiers");
5132    return 0;
5133  }
5134
5135  unsigned Idx = 0;
5136  unsigned NumBases = Record[Idx++];
5137  void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
5138  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
5139  for (unsigned I = 0; I != NumBases; ++I)
5140    Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
5141  return Bases;
5142}
5143
5144serialization::DeclID
5145ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
5146  if (LocalID < NUM_PREDEF_DECL_IDS)
5147    return LocalID;
5148
5149  ContinuousRangeMap<uint32_t, int, 2>::iterator I
5150    = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
5151  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
5152
5153  return LocalID + I->second;
5154}
5155
5156bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
5157                                   ModuleFile &M) const {
5158  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID);
5159  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
5160  return &M == I->second;
5161}
5162
5163ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
5164  if (!D->isFromASTFile())
5165    return 0;
5166  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
5167  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
5168  return I->second;
5169}
5170
5171SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
5172  if (ID < NUM_PREDEF_DECL_IDS)
5173    return SourceLocation();
5174
5175  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
5176
5177  if (Index > DeclsLoaded.size()) {
5178    Error("declaration ID out-of-range for AST file");
5179    return SourceLocation();
5180  }
5181
5182  if (Decl *D = DeclsLoaded[Index])
5183    return D->getLocation();
5184
5185  unsigned RawLocation = 0;
5186  RecordLocation Rec = DeclCursorForID(ID, RawLocation);
5187  return ReadSourceLocation(*Rec.F, RawLocation);
5188}
5189
5190Decl *ASTReader::GetDecl(DeclID ID) {
5191  if (ID < NUM_PREDEF_DECL_IDS) {
5192    switch ((PredefinedDeclIDs)ID) {
5193    case PREDEF_DECL_NULL_ID:
5194      return 0;
5195
5196    case PREDEF_DECL_TRANSLATION_UNIT_ID:
5197      return Context.getTranslationUnitDecl();
5198
5199    case PREDEF_DECL_OBJC_ID_ID:
5200      return Context.getObjCIdDecl();
5201
5202    case PREDEF_DECL_OBJC_SEL_ID:
5203      return Context.getObjCSelDecl();
5204
5205    case PREDEF_DECL_OBJC_CLASS_ID:
5206      return Context.getObjCClassDecl();
5207
5208    case PREDEF_DECL_OBJC_PROTOCOL_ID:
5209      return Context.getObjCProtocolDecl();
5210
5211    case PREDEF_DECL_INT_128_ID:
5212      return Context.getInt128Decl();
5213
5214    case PREDEF_DECL_UNSIGNED_INT_128_ID:
5215      return Context.getUInt128Decl();
5216
5217    case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
5218      return Context.getObjCInstanceTypeDecl();
5219
5220    case PREDEF_DECL_BUILTIN_VA_LIST_ID:
5221      return Context.getBuiltinVaListDecl();
5222    }
5223  }
5224
5225  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
5226
5227  if (Index >= DeclsLoaded.size()) {
5228    assert(0 && "declaration ID out-of-range for AST file");
5229    Error("declaration ID out-of-range for AST file");
5230    return 0;
5231  }
5232
5233  if (!DeclsLoaded[Index]) {
5234    ReadDeclRecord(ID);
5235    if (DeserializationListener)
5236      DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
5237  }
5238
5239  return DeclsLoaded[Index];
5240}
5241
5242DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
5243                                                  DeclID GlobalID) {
5244  if (GlobalID < NUM_PREDEF_DECL_IDS)
5245    return GlobalID;
5246
5247  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
5248  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
5249  ModuleFile *Owner = I->second;
5250
5251  llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
5252    = M.GlobalToLocalDeclIDs.find(Owner);
5253  if (Pos == M.GlobalToLocalDeclIDs.end())
5254    return 0;
5255
5256  return GlobalID - Owner->BaseDeclID + Pos->second;
5257}
5258
5259serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
5260                                            const RecordData &Record,
5261                                            unsigned &Idx) {
5262  if (Idx >= Record.size()) {
5263    Error("Corrupted AST file");
5264    return 0;
5265  }
5266
5267  return getGlobalDeclID(F, Record[Idx++]);
5268}
5269
5270/// \brief Resolve the offset of a statement into a statement.
5271///
5272/// This operation will read a new statement from the external
5273/// source each time it is called, and is meant to be used via a
5274/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
5275Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
5276  // Switch case IDs are per Decl.
5277  ClearSwitchCaseIDs();
5278
5279  // Offset here is a global offset across the entire chain.
5280  RecordLocation Loc = getLocalBitOffset(Offset);
5281  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
5282  return ReadStmtFromStream(*Loc.F);
5283}
5284
5285namespace {
5286  class FindExternalLexicalDeclsVisitor {
5287    ASTReader &Reader;
5288    const DeclContext *DC;
5289    bool (*isKindWeWant)(Decl::Kind);
5290
5291    SmallVectorImpl<Decl*> &Decls;
5292    bool PredefsVisited[NUM_PREDEF_DECL_IDS];
5293
5294  public:
5295    FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
5296                                    bool (*isKindWeWant)(Decl::Kind),
5297                                    SmallVectorImpl<Decl*> &Decls)
5298      : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
5299    {
5300      for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
5301        PredefsVisited[I] = false;
5302    }
5303
5304    static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
5305      if (Preorder)
5306        return false;
5307
5308      FindExternalLexicalDeclsVisitor *This
5309        = static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
5310
5311      ModuleFile::DeclContextInfosMap::iterator Info
5312        = M.DeclContextInfos.find(This->DC);
5313      if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
5314        return false;
5315
5316      // Load all of the declaration IDs
5317      for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
5318                               *IDE = ID + Info->second.NumLexicalDecls;
5319           ID != IDE; ++ID) {
5320        if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
5321          continue;
5322
5323        // Don't add predefined declarations to the lexical context more
5324        // than once.
5325        if (ID->second < NUM_PREDEF_DECL_IDS) {
5326          if (This->PredefsVisited[ID->second])
5327            continue;
5328
5329          This->PredefsVisited[ID->second] = true;
5330        }
5331
5332        if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
5333          if (!This->DC->isDeclInLexicalTraversal(D))
5334            This->Decls.push_back(D);
5335        }
5336      }
5337
5338      return false;
5339    }
5340  };
5341}
5342
5343ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
5344                                         bool (*isKindWeWant)(Decl::Kind),
5345                                         SmallVectorImpl<Decl*> &Decls) {
5346  // There might be lexical decls in multiple modules, for the TU at
5347  // least. Walk all of the modules in the order they were loaded.
5348  FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
5349  ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor);
5350  ++NumLexicalDeclContextsRead;
5351  return ELR_Success;
5352}
5353
5354namespace {
5355
5356class DeclIDComp {
5357  ASTReader &Reader;
5358  ModuleFile &Mod;
5359
5360public:
5361  DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
5362
5363  bool operator()(LocalDeclID L, LocalDeclID R) const {
5364    SourceLocation LHS = getLocation(L);
5365    SourceLocation RHS = getLocation(R);
5366    return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5367  }
5368
5369  bool operator()(SourceLocation LHS, LocalDeclID R) const {
5370    SourceLocation RHS = getLocation(R);
5371    return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5372  }
5373
5374  bool operator()(LocalDeclID L, SourceLocation RHS) const {
5375    SourceLocation LHS = getLocation(L);
5376    return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5377  }
5378
5379  SourceLocation getLocation(LocalDeclID ID) const {
5380    return Reader.getSourceManager().getFileLoc(
5381            Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
5382  }
5383};
5384
5385}
5386
5387void ASTReader::FindFileRegionDecls(FileID File,
5388                                    unsigned Offset, unsigned Length,
5389                                    SmallVectorImpl<Decl *> &Decls) {
5390  SourceManager &SM = getSourceManager();
5391
5392  llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
5393  if (I == FileDeclIDs.end())
5394    return;
5395
5396  FileDeclsInfo &DInfo = I->second;
5397  if (DInfo.Decls.empty())
5398    return;
5399
5400  SourceLocation
5401    BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
5402  SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
5403
5404  DeclIDComp DIDComp(*this, *DInfo.Mod);
5405  ArrayRef<serialization::LocalDeclID>::iterator
5406    BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
5407                               BeginLoc, DIDComp);
5408  if (BeginIt != DInfo.Decls.begin())
5409    --BeginIt;
5410
5411  // If we are pointing at a top-level decl inside an objc container, we need
5412  // to backtrack until we find it otherwise we will fail to report that the
5413  // region overlaps with an objc container.
5414  while (BeginIt != DInfo.Decls.begin() &&
5415         GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
5416             ->isTopLevelDeclInObjCContainer())
5417    --BeginIt;
5418
5419  ArrayRef<serialization::LocalDeclID>::iterator
5420    EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
5421                             EndLoc, DIDComp);
5422  if (EndIt != DInfo.Decls.end())
5423    ++EndIt;
5424
5425  for (ArrayRef<serialization::LocalDeclID>::iterator
5426         DIt = BeginIt; DIt != EndIt; ++DIt)
5427    Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
5428}
5429
5430namespace {
5431  /// \brief ModuleFile visitor used to perform name lookup into a
5432  /// declaration context.
5433  class DeclContextNameLookupVisitor {
5434    ASTReader &Reader;
5435    SmallVectorImpl<const DeclContext *> &Contexts;
5436    DeclarationName Name;
5437    SmallVectorImpl<NamedDecl *> &Decls;
5438
5439  public:
5440    DeclContextNameLookupVisitor(ASTReader &Reader,
5441                                 SmallVectorImpl<const DeclContext *> &Contexts,
5442                                 DeclarationName Name,
5443                                 SmallVectorImpl<NamedDecl *> &Decls)
5444      : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { }
5445
5446    static bool visit(ModuleFile &M, void *UserData) {
5447      DeclContextNameLookupVisitor *This
5448        = static_cast<DeclContextNameLookupVisitor *>(UserData);
5449
5450      // Check whether we have any visible declaration information for
5451      // this context in this module.
5452      ModuleFile::DeclContextInfosMap::iterator Info;
5453      bool FoundInfo = false;
5454      for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
5455        Info = M.DeclContextInfos.find(This->Contexts[I]);
5456        if (Info != M.DeclContextInfos.end() &&
5457            Info->second.NameLookupTableData) {
5458          FoundInfo = true;
5459          break;
5460        }
5461      }
5462
5463      if (!FoundInfo)
5464        return false;
5465
5466      // Look for this name within this module.
5467      ASTDeclContextNameLookupTable *LookupTable =
5468        Info->second.NameLookupTableData;
5469      ASTDeclContextNameLookupTable::iterator Pos
5470        = LookupTable->find(This->Name);
5471      if (Pos == LookupTable->end())
5472        return false;
5473
5474      bool FoundAnything = false;
5475      ASTDeclContextNameLookupTrait::data_type Data = *Pos;
5476      for (; Data.first != Data.second; ++Data.first) {
5477        NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
5478        if (!ND)
5479          continue;
5480
5481        if (ND->getDeclName() != This->Name) {
5482          // A name might be null because the decl's redeclarable part is
5483          // currently read before reading its name. The lookup is triggered by
5484          // building that decl (likely indirectly), and so it is later in the
5485          // sense of "already existing" and can be ignored here.
5486          continue;
5487        }
5488
5489        // Record this declaration.
5490        FoundAnything = true;
5491        This->Decls.push_back(ND);
5492      }
5493
5494      return FoundAnything;
5495    }
5496  };
5497}
5498
5499/// \brief Retrieve the "definitive" module file for the definition of the
5500/// given declaration context, if there is one.
5501///
5502/// The "definitive" module file is the only place where we need to look to
5503/// find information about the declarations within the given declaration
5504/// context. For example, C++ and Objective-C classes, C structs/unions, and
5505/// Objective-C protocols, categories, and extensions are all defined in a
5506/// single place in the source code, so they have definitive module files
5507/// associated with them. C++ namespaces, on the other hand, can have
5508/// definitions in multiple different module files.
5509///
5510/// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's
5511/// NDEBUG checking.
5512static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC,
5513                                              ASTReader &Reader) {
5514  if (const DeclContext *DefDC = getDefinitiveDeclContext(DC))
5515    return Reader.getOwningModuleFile(cast<Decl>(DefDC));
5516
5517  return 0;
5518}
5519
5520bool
5521ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
5522                                          DeclarationName Name) {
5523  assert(DC->hasExternalVisibleStorage() &&
5524         "DeclContext has no visible decls in storage");
5525  if (!Name)
5526    return false;
5527
5528  SmallVector<NamedDecl *, 64> Decls;
5529
5530  // Compute the declaration contexts we need to look into. Multiple such
5531  // declaration contexts occur when two declaration contexts from disjoint
5532  // modules get merged, e.g., when two namespaces with the same name are
5533  // independently defined in separate modules.
5534  SmallVector<const DeclContext *, 2> Contexts;
5535  Contexts.push_back(DC);
5536
5537  if (DC->isNamespace()) {
5538    MergedDeclsMap::iterator Merged
5539      = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
5540    if (Merged != MergedDecls.end()) {
5541      for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
5542        Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
5543    }
5544  }
5545
5546  DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls);
5547
5548  // If we can definitively determine which module file to look into,
5549  // only look there. Otherwise, look in all module files.
5550  ModuleFile *Definitive;
5551  if (Contexts.size() == 1 &&
5552      (Definitive = getDefinitiveModuleFileFor(DC, *this))) {
5553    DeclContextNameLookupVisitor::visit(*Definitive, &Visitor);
5554  } else {
5555    ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
5556  }
5557  ++NumVisibleDeclContextsRead;
5558  SetExternalVisibleDeclsForName(DC, Name, Decls);
5559  return !Decls.empty();
5560}
5561
5562namespace {
5563  /// \brief ModuleFile visitor used to retrieve all visible names in a
5564  /// declaration context.
5565  class DeclContextAllNamesVisitor {
5566    ASTReader &Reader;
5567    SmallVectorImpl<const DeclContext *> &Contexts;
5568    llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > &Decls;
5569    bool VisitAll;
5570
5571  public:
5572    DeclContextAllNamesVisitor(ASTReader &Reader,
5573                               SmallVectorImpl<const DeclContext *> &Contexts,
5574                               llvm::DenseMap<DeclarationName,
5575                                           SmallVector<NamedDecl *, 8> > &Decls,
5576                                bool VisitAll)
5577      : Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { }
5578
5579    static bool visit(ModuleFile &M, void *UserData) {
5580      DeclContextAllNamesVisitor *This
5581        = static_cast<DeclContextAllNamesVisitor *>(UserData);
5582
5583      // Check whether we have any visible declaration information for
5584      // this context in this module.
5585      ModuleFile::DeclContextInfosMap::iterator Info;
5586      bool FoundInfo = false;
5587      for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
5588        Info = M.DeclContextInfos.find(This->Contexts[I]);
5589        if (Info != M.DeclContextInfos.end() &&
5590            Info->second.NameLookupTableData) {
5591          FoundInfo = true;
5592          break;
5593        }
5594      }
5595
5596      if (!FoundInfo)
5597        return false;
5598
5599      ASTDeclContextNameLookupTable *LookupTable =
5600        Info->second.NameLookupTableData;
5601      bool FoundAnything = false;
5602      for (ASTDeclContextNameLookupTable::data_iterator
5603             I = LookupTable->data_begin(), E = LookupTable->data_end();
5604           I != E;
5605           ++I) {
5606        ASTDeclContextNameLookupTrait::data_type Data = *I;
5607        for (; Data.first != Data.second; ++Data.first) {
5608          NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M,
5609                                                                 *Data.first);
5610          if (!ND)
5611            continue;
5612
5613          // Record this declaration.
5614          FoundAnything = true;
5615          This->Decls[ND->getDeclName()].push_back(ND);
5616        }
5617      }
5618
5619      return FoundAnything && !This->VisitAll;
5620    }
5621  };
5622}
5623
5624void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
5625  if (!DC->hasExternalVisibleStorage())
5626    return;
5627  llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > Decls;
5628
5629  // Compute the declaration contexts we need to look into. Multiple such
5630  // declaration contexts occur when two declaration contexts from disjoint
5631  // modules get merged, e.g., when two namespaces with the same name are
5632  // independently defined in separate modules.
5633  SmallVector<const DeclContext *, 2> Contexts;
5634  Contexts.push_back(DC);
5635
5636  if (DC->isNamespace()) {
5637    MergedDeclsMap::iterator Merged
5638      = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
5639    if (Merged != MergedDecls.end()) {
5640      for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
5641        Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
5642    }
5643  }
5644
5645  DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls,
5646                                     /*VisitAll=*/DC->isFileContext());
5647  ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor);
5648  ++NumVisibleDeclContextsRead;
5649
5650  for (llvm::DenseMap<DeclarationName,
5651                      SmallVector<NamedDecl *, 8> >::iterator
5652         I = Decls.begin(), E = Decls.end(); I != E; ++I) {
5653    SetExternalVisibleDeclsForName(DC, I->first, I->second);
5654  }
5655  const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
5656}
5657
5658/// \brief Under non-PCH compilation the consumer receives the objc methods
5659/// before receiving the implementation, and codegen depends on this.
5660/// We simulate this by deserializing and passing to consumer the methods of the
5661/// implementation before passing the deserialized implementation decl.
5662static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
5663                                       ASTConsumer *Consumer) {
5664  assert(ImplD && Consumer);
5665
5666  for (ObjCImplDecl::method_iterator
5667         I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I)
5668    Consumer->HandleInterestingDecl(DeclGroupRef(*I));
5669
5670  Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
5671}
5672
5673void ASTReader::PassInterestingDeclsToConsumer() {
5674  assert(Consumer);
5675  while (!InterestingDecls.empty()) {
5676    Decl *D = InterestingDecls.front();
5677    InterestingDecls.pop_front();
5678
5679    PassInterestingDeclToConsumer(D);
5680  }
5681}
5682
5683void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
5684  if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
5685    PassObjCImplDeclToConsumer(ImplD, Consumer);
5686  else
5687    Consumer->HandleInterestingDecl(DeclGroupRef(D));
5688}
5689
5690void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
5691  this->Consumer = Consumer;
5692
5693  if (!Consumer)
5694    return;
5695
5696  for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) {
5697    // Force deserialization of this decl, which will cause it to be queued for
5698    // passing to the consumer.
5699    GetDecl(ExternalDefinitions[I]);
5700  }
5701  ExternalDefinitions.clear();
5702
5703  PassInterestingDeclsToConsumer();
5704}
5705
5706void ASTReader::PrintStats() {
5707  std::fprintf(stderr, "*** AST File Statistics:\n");
5708
5709  unsigned NumTypesLoaded
5710    = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
5711                                      QualType());
5712  unsigned NumDeclsLoaded
5713    = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
5714                                      (Decl *)0);
5715  unsigned NumIdentifiersLoaded
5716    = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
5717                                            IdentifiersLoaded.end(),
5718                                            (IdentifierInfo *)0);
5719  unsigned NumMacrosLoaded
5720    = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
5721                                       MacrosLoaded.end(),
5722                                       (MacroDirective *)0);
5723  unsigned NumSelectorsLoaded
5724    = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
5725                                          SelectorsLoaded.end(),
5726                                          Selector());
5727
5728  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
5729    std::fprintf(stderr, "  %u/%u source location entries read (%f%%)\n",
5730                 NumSLocEntriesRead, TotalNumSLocEntries,
5731                 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
5732  if (!TypesLoaded.empty())
5733    std::fprintf(stderr, "  %u/%u types read (%f%%)\n",
5734                 NumTypesLoaded, (unsigned)TypesLoaded.size(),
5735                 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
5736  if (!DeclsLoaded.empty())
5737    std::fprintf(stderr, "  %u/%u declarations read (%f%%)\n",
5738                 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
5739                 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
5740  if (!IdentifiersLoaded.empty())
5741    std::fprintf(stderr, "  %u/%u identifiers read (%f%%)\n",
5742                 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
5743                 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
5744  if (!MacrosLoaded.empty())
5745    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
5746                 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
5747                 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
5748  if (!SelectorsLoaded.empty())
5749    std::fprintf(stderr, "  %u/%u selectors read (%f%%)\n",
5750                 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
5751                 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
5752  if (TotalNumStatements)
5753    std::fprintf(stderr, "  %u/%u statements read (%f%%)\n",
5754                 NumStatementsRead, TotalNumStatements,
5755                 ((float)NumStatementsRead/TotalNumStatements * 100));
5756  if (TotalNumMacros)
5757    std::fprintf(stderr, "  %u/%u macros read (%f%%)\n",
5758                 NumMacrosRead, TotalNumMacros,
5759                 ((float)NumMacrosRead/TotalNumMacros * 100));
5760  if (TotalLexicalDeclContexts)
5761    std::fprintf(stderr, "  %u/%u lexical declcontexts read (%f%%)\n",
5762                 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
5763                 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
5764                  * 100));
5765  if (TotalVisibleDeclContexts)
5766    std::fprintf(stderr, "  %u/%u visible declcontexts read (%f%%)\n",
5767                 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
5768                 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
5769                  * 100));
5770  if (TotalNumMethodPoolEntries) {
5771    std::fprintf(stderr, "  %u/%u method pool entries read (%f%%)\n",
5772                 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
5773                 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
5774                  * 100));
5775  }
5776  if (NumMethodPoolLookups) {
5777    std::fprintf(stderr, "  %u/%u method pool lookups succeeded (%f%%)\n",
5778                 NumMethodPoolHits, NumMethodPoolLookups,
5779                 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
5780  }
5781  if (NumMethodPoolTableLookups) {
5782    std::fprintf(stderr, "  %u/%u method pool table lookups succeeded (%f%%)\n",
5783                 NumMethodPoolTableHits, NumMethodPoolTableLookups,
5784                 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
5785                  * 100.0));
5786  }
5787
5788  if (NumIdentifierLookupHits) {
5789    std::fprintf(stderr,
5790                 "  %u / %u identifier table lookups succeeded (%f%%)\n",
5791                 NumIdentifierLookupHits, NumIdentifierLookups,
5792                 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
5793  }
5794
5795  if (GlobalIndex) {
5796    std::fprintf(stderr, "\n");
5797    GlobalIndex->printStats();
5798  }
5799
5800  std::fprintf(stderr, "\n");
5801  dump();
5802  std::fprintf(stderr, "\n");
5803}
5804
5805template<typename Key, typename ModuleFile, unsigned InitialCapacity>
5806static void
5807dumpModuleIDMap(StringRef Name,
5808                const ContinuousRangeMap<Key, ModuleFile *,
5809                                         InitialCapacity> &Map) {
5810  if (Map.begin() == Map.end())
5811    return;
5812
5813  typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
5814  llvm::errs() << Name << ":\n";
5815  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
5816       I != IEnd; ++I) {
5817    llvm::errs() << "  " << I->first << " -> " << I->second->FileName
5818      << "\n";
5819  }
5820}
5821
5822void ASTReader::dump() {
5823  llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
5824  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
5825  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
5826  dumpModuleIDMap("Global type map", GlobalTypeMap);
5827  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
5828  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
5829  dumpModuleIDMap("Global macro map", GlobalMacroMap);
5830  dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
5831  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
5832  dumpModuleIDMap("Global preprocessed entity map",
5833                  GlobalPreprocessedEntityMap);
5834
5835  llvm::errs() << "\n*** PCH/Modules Loaded:";
5836  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
5837                                       MEnd = ModuleMgr.end();
5838       M != MEnd; ++M)
5839    (*M)->dump();
5840}
5841
5842/// Return the amount of memory used by memory buffers, breaking down
5843/// by heap-backed versus mmap'ed memory.
5844void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
5845  for (ModuleConstIterator I = ModuleMgr.begin(),
5846      E = ModuleMgr.end(); I != E; ++I) {
5847    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
5848      size_t bytes = buf->getBufferSize();
5849      switch (buf->getBufferKind()) {
5850        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
5851          sizes.malloc_bytes += bytes;
5852          break;
5853        case llvm::MemoryBuffer::MemoryBuffer_MMap:
5854          sizes.mmap_bytes += bytes;
5855          break;
5856      }
5857    }
5858  }
5859}
5860
5861void ASTReader::InitializeSema(Sema &S) {
5862  SemaObj = &S;
5863  S.addExternalSource(this);
5864
5865  // Makes sure any declarations that were deserialized "too early"
5866  // still get added to the identifier's declaration chains.
5867  for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) {
5868    NamedDecl *ND = cast<NamedDecl>(PreloadedDecls[I]->getMostRecentDecl());
5869    SemaObj->pushExternalDeclIntoScope(ND, PreloadedDecls[I]->getDeclName());
5870  }
5871  PreloadedDecls.clear();
5872
5873  // Load the offsets of the declarations that Sema references.
5874  // They will be lazily deserialized when needed.
5875  if (!SemaDeclRefs.empty()) {
5876    assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!");
5877    if (!SemaObj->StdNamespace)
5878      SemaObj->StdNamespace = SemaDeclRefs[0];
5879    if (!SemaObj->StdBadAlloc)
5880      SemaObj->StdBadAlloc = SemaDeclRefs[1];
5881  }
5882
5883  if (!FPPragmaOptions.empty()) {
5884    assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
5885    SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
5886  }
5887
5888  if (!OpenCLExtensions.empty()) {
5889    unsigned I = 0;
5890#define OPENCLEXT(nm)  SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
5891#include "clang/Basic/OpenCLExtensions.def"
5892
5893    assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
5894  }
5895}
5896
5897IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
5898  // Note that we are loading an identifier.
5899  Deserializing AnIdentifier(this);
5900  StringRef Name(NameStart, NameEnd - NameStart);
5901
5902  // If there is a global index, look there first to determine which modules
5903  // provably do not have any results for this identifier.
5904  GlobalModuleIndex::HitSet Hits;
5905  GlobalModuleIndex::HitSet *HitsPtr = 0;
5906  if (!loadGlobalIndex()) {
5907    if (GlobalIndex->lookupIdentifier(Name, Hits)) {
5908      HitsPtr = &Hits;
5909    }
5910  }
5911  IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
5912                                  NumIdentifierLookups,
5913                                  NumIdentifierLookupHits);
5914  ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr);
5915  IdentifierInfo *II = Visitor.getIdentifierInfo();
5916  markIdentifierUpToDate(II);
5917  return II;
5918}
5919
5920namespace clang {
5921  /// \brief An identifier-lookup iterator that enumerates all of the
5922  /// identifiers stored within a set of AST files.
5923  class ASTIdentifierIterator : public IdentifierIterator {
5924    /// \brief The AST reader whose identifiers are being enumerated.
5925    const ASTReader &Reader;
5926
5927    /// \brief The current index into the chain of AST files stored in
5928    /// the AST reader.
5929    unsigned Index;
5930
5931    /// \brief The current position within the identifier lookup table
5932    /// of the current AST file.
5933    ASTIdentifierLookupTable::key_iterator Current;
5934
5935    /// \brief The end position within the identifier lookup table of
5936    /// the current AST file.
5937    ASTIdentifierLookupTable::key_iterator End;
5938
5939  public:
5940    explicit ASTIdentifierIterator(const ASTReader &Reader);
5941
5942    virtual StringRef Next();
5943  };
5944}
5945
5946ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
5947  : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
5948  ASTIdentifierLookupTable *IdTable
5949    = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
5950  Current = IdTable->key_begin();
5951  End = IdTable->key_end();
5952}
5953
5954StringRef ASTIdentifierIterator::Next() {
5955  while (Current == End) {
5956    // If we have exhausted all of our AST files, we're done.
5957    if (Index == 0)
5958      return StringRef();
5959
5960    --Index;
5961    ASTIdentifierLookupTable *IdTable
5962      = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
5963        IdentifierLookupTable;
5964    Current = IdTable->key_begin();
5965    End = IdTable->key_end();
5966  }
5967
5968  // We have any identifiers remaining in the current AST file; return
5969  // the next one.
5970  StringRef Result = *Current;
5971  ++Current;
5972  return Result;
5973}
5974
5975IdentifierIterator *ASTReader::getIdentifiers() const {
5976  return new ASTIdentifierIterator(*this);
5977}
5978
5979namespace clang { namespace serialization {
5980  class ReadMethodPoolVisitor {
5981    ASTReader &Reader;
5982    Selector Sel;
5983    unsigned PriorGeneration;
5984    SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
5985    SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
5986
5987  public:
5988    ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
5989                          unsigned PriorGeneration)
5990      : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) { }
5991
5992    static bool visit(ModuleFile &M, void *UserData) {
5993      ReadMethodPoolVisitor *This
5994        = static_cast<ReadMethodPoolVisitor *>(UserData);
5995
5996      if (!M.SelectorLookupTable)
5997        return false;
5998
5999      // If we've already searched this module file, skip it now.
6000      if (M.Generation <= This->PriorGeneration)
6001        return true;
6002
6003      ++This->Reader.NumMethodPoolTableLookups;
6004      ASTSelectorLookupTable *PoolTable
6005        = (ASTSelectorLookupTable*)M.SelectorLookupTable;
6006      ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
6007      if (Pos == PoolTable->end())
6008        return false;
6009
6010      ++This->Reader.NumMethodPoolTableHits;
6011      ++This->Reader.NumSelectorsRead;
6012      // FIXME: Not quite happy with the statistics here. We probably should
6013      // disable this tracking when called via LoadSelector.
6014      // Also, should entries without methods count as misses?
6015      ++This->Reader.NumMethodPoolEntriesRead;
6016      ASTSelectorLookupTrait::data_type Data = *Pos;
6017      if (This->Reader.DeserializationListener)
6018        This->Reader.DeserializationListener->SelectorRead(Data.ID,
6019                                                           This->Sel);
6020
6021      This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
6022      This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
6023      return true;
6024    }
6025
6026    /// \brief Retrieve the instance methods found by this visitor.
6027    ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
6028      return InstanceMethods;
6029    }
6030
6031    /// \brief Retrieve the instance methods found by this visitor.
6032    ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
6033      return FactoryMethods;
6034    }
6035  };
6036} } // end namespace clang::serialization
6037
6038/// \brief Add the given set of methods to the method list.
6039static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
6040                             ObjCMethodList &List) {
6041  for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
6042    S.addMethodToGlobalList(&List, Methods[I]);
6043  }
6044}
6045
6046void ASTReader::ReadMethodPool(Selector Sel) {
6047  // Get the selector generation and update it to the current generation.
6048  unsigned &Generation = SelectorGeneration[Sel];
6049  unsigned PriorGeneration = Generation;
6050  Generation = CurrentGeneration;
6051
6052  // Search for methods defined with this selector.
6053  ++NumMethodPoolLookups;
6054  ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
6055  ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
6056
6057  if (Visitor.getInstanceMethods().empty() &&
6058      Visitor.getFactoryMethods().empty())
6059    return;
6060
6061  ++NumMethodPoolHits;
6062
6063  if (!getSema())
6064    return;
6065
6066  Sema &S = *getSema();
6067  Sema::GlobalMethodPool::iterator Pos
6068    = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
6069
6070  addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
6071  addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
6072}
6073
6074void ASTReader::ReadKnownNamespaces(
6075                          SmallVectorImpl<NamespaceDecl *> &Namespaces) {
6076  Namespaces.clear();
6077
6078  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
6079    if (NamespaceDecl *Namespace
6080                = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
6081      Namespaces.push_back(Namespace);
6082  }
6083}
6084
6085void ASTReader::ReadUndefinedButUsed(
6086                        llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) {
6087  for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
6088    NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
6089    SourceLocation Loc =
6090        SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
6091    Undefined.insert(std::make_pair(D, Loc));
6092  }
6093}
6094
6095void ASTReader::ReadTentativeDefinitions(
6096                  SmallVectorImpl<VarDecl *> &TentativeDefs) {
6097  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
6098    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
6099    if (Var)
6100      TentativeDefs.push_back(Var);
6101  }
6102  TentativeDefinitions.clear();
6103}
6104
6105void ASTReader::ReadUnusedFileScopedDecls(
6106                               SmallVectorImpl<const DeclaratorDecl *> &Decls) {
6107  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
6108    DeclaratorDecl *D
6109      = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
6110    if (D)
6111      Decls.push_back(D);
6112  }
6113  UnusedFileScopedDecls.clear();
6114}
6115
6116void ASTReader::ReadDelegatingConstructors(
6117                                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
6118  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
6119    CXXConstructorDecl *D
6120      = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
6121    if (D)
6122      Decls.push_back(D);
6123  }
6124  DelegatingCtorDecls.clear();
6125}
6126
6127void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
6128  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
6129    TypedefNameDecl *D
6130      = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
6131    if (D)
6132      Decls.push_back(D);
6133  }
6134  ExtVectorDecls.clear();
6135}
6136
6137void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) {
6138  for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
6139    CXXRecordDecl *D
6140      = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I]));
6141    if (D)
6142      Decls.push_back(D);
6143  }
6144  DynamicClasses.clear();
6145}
6146
6147void
6148ASTReader::ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl *> &Decls) {
6149  for (unsigned I = 0, N = LocallyScopedExternCDecls.size(); I != N; ++I) {
6150    NamedDecl *D
6151      = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternCDecls[I]));
6152    if (D)
6153      Decls.push_back(D);
6154  }
6155  LocallyScopedExternCDecls.clear();
6156}
6157
6158void ASTReader::ReadReferencedSelectors(
6159       SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
6160  if (ReferencedSelectorsData.empty())
6161    return;
6162
6163  // If there are @selector references added them to its pool. This is for
6164  // implementation of -Wselector.
6165  unsigned int DataSize = ReferencedSelectorsData.size()-1;
6166  unsigned I = 0;
6167  while (I < DataSize) {
6168    Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
6169    SourceLocation SelLoc
6170      = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
6171    Sels.push_back(std::make_pair(Sel, SelLoc));
6172  }
6173  ReferencedSelectorsData.clear();
6174}
6175
6176void ASTReader::ReadWeakUndeclaredIdentifiers(
6177       SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
6178  if (WeakUndeclaredIdentifiers.empty())
6179    return;
6180
6181  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
6182    IdentifierInfo *WeakId
6183      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
6184    IdentifierInfo *AliasId
6185      = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
6186    SourceLocation Loc
6187      = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
6188    bool Used = WeakUndeclaredIdentifiers[I++];
6189    WeakInfo WI(AliasId, Loc);
6190    WI.setUsed(Used);
6191    WeakIDs.push_back(std::make_pair(WeakId, WI));
6192  }
6193  WeakUndeclaredIdentifiers.clear();
6194}
6195
6196void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
6197  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
6198    ExternalVTableUse VT;
6199    VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
6200    VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
6201    VT.DefinitionRequired = VTableUses[Idx++];
6202    VTables.push_back(VT);
6203  }
6204
6205  VTableUses.clear();
6206}
6207
6208void ASTReader::ReadPendingInstantiations(
6209       SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
6210  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
6211    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
6212    SourceLocation Loc
6213      = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
6214
6215    Pending.push_back(std::make_pair(D, Loc));
6216  }
6217  PendingInstantiations.clear();
6218}
6219
6220void ASTReader::LoadSelector(Selector Sel) {
6221  // It would be complicated to avoid reading the methods anyway. So don't.
6222  ReadMethodPool(Sel);
6223}
6224
6225void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
6226  assert(ID && "Non-zero identifier ID required");
6227  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
6228  IdentifiersLoaded[ID - 1] = II;
6229  if (DeserializationListener)
6230    DeserializationListener->IdentifierRead(ID, II);
6231}
6232
6233/// \brief Set the globally-visible declarations associated with the given
6234/// identifier.
6235///
6236/// If the AST reader is currently in a state where the given declaration IDs
6237/// cannot safely be resolved, they are queued until it is safe to resolve
6238/// them.
6239///
6240/// \param II an IdentifierInfo that refers to one or more globally-visible
6241/// declarations.
6242///
6243/// \param DeclIDs the set of declaration IDs with the name @p II that are
6244/// visible at global scope.
6245///
6246/// \param Decls if non-null, this vector will be populated with the set of
6247/// deserialized declarations. These declarations will not be pushed into
6248/// scope.
6249void
6250ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
6251                              const SmallVectorImpl<uint32_t> &DeclIDs,
6252                                   SmallVectorImpl<Decl *> *Decls) {
6253  if (NumCurrentElementsDeserializing && !Decls) {
6254    PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
6255    return;
6256  }
6257
6258  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
6259    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
6260    if (SemaObj) {
6261      // If we're simply supposed to record the declarations, do so now.
6262      if (Decls) {
6263        Decls->push_back(D);
6264        continue;
6265      }
6266
6267      // Introduce this declaration into the translation-unit scope
6268      // and add it to the declaration chain for this identifier, so
6269      // that (unqualified) name lookup will find it.
6270      NamedDecl *ND = cast<NamedDecl>(D->getMostRecentDecl());
6271      SemaObj->pushExternalDeclIntoScope(ND, II);
6272    } else {
6273      // Queue this declaration so that it will be added to the
6274      // translation unit scope and identifier's declaration chain
6275      // once a Sema object is known.
6276      PreloadedDecls.push_back(D);
6277    }
6278  }
6279}
6280
6281IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
6282  if (ID == 0)
6283    return 0;
6284
6285  if (IdentifiersLoaded.empty()) {
6286    Error("no identifier table in AST file");
6287    return 0;
6288  }
6289
6290  ID -= 1;
6291  if (!IdentifiersLoaded[ID]) {
6292    GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
6293    assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
6294    ModuleFile *M = I->second;
6295    unsigned Index = ID - M->BaseIdentifierID;
6296    const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
6297
6298    // All of the strings in the AST file are preceded by a 16-bit length.
6299    // Extract that 16-bit length to avoid having to execute strlen().
6300    // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
6301    //  unsigned integers.  This is important to avoid integer overflow when
6302    //  we cast them to 'unsigned'.
6303    const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
6304    unsigned StrLen = (((unsigned) StrLenPtr[0])
6305                       | (((unsigned) StrLenPtr[1]) << 8)) - 1;
6306    IdentifiersLoaded[ID]
6307      = &PP.getIdentifierTable().get(StringRef(Str, StrLen));
6308    if (DeserializationListener)
6309      DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
6310  }
6311
6312  return IdentifiersLoaded[ID];
6313}
6314
6315IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
6316  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
6317}
6318
6319IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
6320  if (LocalID < NUM_PREDEF_IDENT_IDS)
6321    return LocalID;
6322
6323  ContinuousRangeMap<uint32_t, int, 2>::iterator I
6324    = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
6325  assert(I != M.IdentifierRemap.end()
6326         && "Invalid index into identifier index remap");
6327
6328  return LocalID + I->second;
6329}
6330
6331MacroDirective *ASTReader::getMacro(MacroID ID, MacroDirective *Hint) {
6332  if (ID == 0)
6333    return 0;
6334
6335  if (MacrosLoaded.empty()) {
6336    Error("no macro table in AST file");
6337    return 0;
6338  }
6339
6340  ID -= NUM_PREDEF_MACRO_IDS;
6341  if (!MacrosLoaded[ID]) {
6342    GlobalMacroMapType::iterator I
6343      = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
6344    assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
6345    ModuleFile *M = I->second;
6346    unsigned Index = ID - M->BaseMacroID;
6347    ReadMacroRecord(*M, M->MacroOffsets[Index], Hint);
6348  }
6349
6350  return MacrosLoaded[ID];
6351}
6352
6353MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
6354  if (LocalID < NUM_PREDEF_MACRO_IDS)
6355    return LocalID;
6356
6357  ContinuousRangeMap<uint32_t, int, 2>::iterator I
6358    = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
6359  assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
6360
6361  return LocalID + I->second;
6362}
6363
6364serialization::SubmoduleID
6365ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
6366  if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
6367    return LocalID;
6368
6369  ContinuousRangeMap<uint32_t, int, 2>::iterator I
6370    = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
6371  assert(I != M.SubmoduleRemap.end()
6372         && "Invalid index into submodule index remap");
6373
6374  return LocalID + I->second;
6375}
6376
6377Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
6378  if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
6379    assert(GlobalID == 0 && "Unhandled global submodule ID");
6380    return 0;
6381  }
6382
6383  if (GlobalID > SubmodulesLoaded.size()) {
6384    Error("submodule ID out of range in AST file");
6385    return 0;
6386  }
6387
6388  return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
6389}
6390
6391Module *ASTReader::getModule(unsigned ID) {
6392  return getSubmodule(ID);
6393}
6394
6395Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
6396  return DecodeSelector(getGlobalSelectorID(M, LocalID));
6397}
6398
6399Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
6400  if (ID == 0)
6401    return Selector();
6402
6403  if (ID > SelectorsLoaded.size()) {
6404    Error("selector ID out of range in AST file");
6405    return Selector();
6406  }
6407
6408  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) {
6409    // Load this selector from the selector table.
6410    GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
6411    assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
6412    ModuleFile &M = *I->second;
6413    ASTSelectorLookupTrait Trait(*this, M);
6414    unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
6415    SelectorsLoaded[ID - 1] =
6416      Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
6417    if (DeserializationListener)
6418      DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
6419  }
6420
6421  return SelectorsLoaded[ID - 1];
6422}
6423
6424Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
6425  return DecodeSelector(ID);
6426}
6427
6428uint32_t ASTReader::GetNumExternalSelectors() {
6429  // ID 0 (the null selector) is considered an external selector.
6430  return getTotalNumSelectors() + 1;
6431}
6432
6433serialization::SelectorID
6434ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
6435  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
6436    return LocalID;
6437
6438  ContinuousRangeMap<uint32_t, int, 2>::iterator I
6439    = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
6440  assert(I != M.SelectorRemap.end()
6441         && "Invalid index into selector index remap");
6442
6443  return LocalID + I->second;
6444}
6445
6446DeclarationName
6447ASTReader::ReadDeclarationName(ModuleFile &F,
6448                               const RecordData &Record, unsigned &Idx) {
6449  DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
6450  switch (Kind) {
6451  case DeclarationName::Identifier:
6452    return DeclarationName(GetIdentifierInfo(F, Record, Idx));
6453
6454  case DeclarationName::ObjCZeroArgSelector:
6455  case DeclarationName::ObjCOneArgSelector:
6456  case DeclarationName::ObjCMultiArgSelector:
6457    return DeclarationName(ReadSelector(F, Record, Idx));
6458
6459  case DeclarationName::CXXConstructorName:
6460    return Context.DeclarationNames.getCXXConstructorName(
6461                          Context.getCanonicalType(readType(F, Record, Idx)));
6462
6463  case DeclarationName::CXXDestructorName:
6464    return Context.DeclarationNames.getCXXDestructorName(
6465                          Context.getCanonicalType(readType(F, Record, Idx)));
6466
6467  case DeclarationName::CXXConversionFunctionName:
6468    return Context.DeclarationNames.getCXXConversionFunctionName(
6469                          Context.getCanonicalType(readType(F, Record, Idx)));
6470
6471  case DeclarationName::CXXOperatorName:
6472    return Context.DeclarationNames.getCXXOperatorName(
6473                                       (OverloadedOperatorKind)Record[Idx++]);
6474
6475  case DeclarationName::CXXLiteralOperatorName:
6476    return Context.DeclarationNames.getCXXLiteralOperatorName(
6477                                       GetIdentifierInfo(F, Record, Idx));
6478
6479  case DeclarationName::CXXUsingDirective:
6480    return DeclarationName::getUsingDirectiveName();
6481  }
6482
6483  llvm_unreachable("Invalid NameKind!");
6484}
6485
6486void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
6487                                       DeclarationNameLoc &DNLoc,
6488                                       DeclarationName Name,
6489                                      const RecordData &Record, unsigned &Idx) {
6490  switch (Name.getNameKind()) {
6491  case DeclarationName::CXXConstructorName:
6492  case DeclarationName::CXXDestructorName:
6493  case DeclarationName::CXXConversionFunctionName:
6494    DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
6495    break;
6496
6497  case DeclarationName::CXXOperatorName:
6498    DNLoc.CXXOperatorName.BeginOpNameLoc
6499        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
6500    DNLoc.CXXOperatorName.EndOpNameLoc
6501        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
6502    break;
6503
6504  case DeclarationName::CXXLiteralOperatorName:
6505    DNLoc.CXXLiteralOperatorName.OpNameLoc
6506        = ReadSourceLocation(F, Record, Idx).getRawEncoding();
6507    break;
6508
6509  case DeclarationName::Identifier:
6510  case DeclarationName::ObjCZeroArgSelector:
6511  case DeclarationName::ObjCOneArgSelector:
6512  case DeclarationName::ObjCMultiArgSelector:
6513  case DeclarationName::CXXUsingDirective:
6514    break;
6515  }
6516}
6517
6518void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
6519                                        DeclarationNameInfo &NameInfo,
6520                                      const RecordData &Record, unsigned &Idx) {
6521  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
6522  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
6523  DeclarationNameLoc DNLoc;
6524  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
6525  NameInfo.setInfo(DNLoc);
6526}
6527
6528void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
6529                                  const RecordData &Record, unsigned &Idx) {
6530  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
6531  unsigned NumTPLists = Record[Idx++];
6532  Info.NumTemplParamLists = NumTPLists;
6533  if (NumTPLists) {
6534    Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
6535    for (unsigned i=0; i != NumTPLists; ++i)
6536      Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
6537  }
6538}
6539
6540TemplateName
6541ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
6542                            unsigned &Idx) {
6543  TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
6544  switch (Kind) {
6545  case TemplateName::Template:
6546      return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
6547
6548  case TemplateName::OverloadedTemplate: {
6549    unsigned size = Record[Idx++];
6550    UnresolvedSet<8> Decls;
6551    while (size--)
6552      Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
6553
6554    return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
6555  }
6556
6557  case TemplateName::QualifiedTemplate: {
6558    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
6559    bool hasTemplKeyword = Record[Idx++];
6560    TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
6561    return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
6562  }
6563
6564  case TemplateName::DependentTemplate: {
6565    NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
6566    if (Record[Idx++])  // isIdentifier
6567      return Context.getDependentTemplateName(NNS,
6568                                               GetIdentifierInfo(F, Record,
6569                                                                 Idx));
6570    return Context.getDependentTemplateName(NNS,
6571                                         (OverloadedOperatorKind)Record[Idx++]);
6572  }
6573
6574  case TemplateName::SubstTemplateTemplateParm: {
6575    TemplateTemplateParmDecl *param
6576      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
6577    if (!param) return TemplateName();
6578    TemplateName replacement = ReadTemplateName(F, Record, Idx);
6579    return Context.getSubstTemplateTemplateParm(param, replacement);
6580  }
6581
6582  case TemplateName::SubstTemplateTemplateParmPack: {
6583    TemplateTemplateParmDecl *Param
6584      = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
6585    if (!Param)
6586      return TemplateName();
6587
6588    TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
6589    if (ArgPack.getKind() != TemplateArgument::Pack)
6590      return TemplateName();
6591
6592    return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
6593  }
6594  }
6595
6596  llvm_unreachable("Unhandled template name kind!");
6597}
6598
6599TemplateArgument
6600ASTReader::ReadTemplateArgument(ModuleFile &F,
6601                                const RecordData &Record, unsigned &Idx) {
6602  TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
6603  switch (Kind) {
6604  case TemplateArgument::Null:
6605    return TemplateArgument();
6606  case TemplateArgument::Type:
6607    return TemplateArgument(readType(F, Record, Idx));
6608  case TemplateArgument::Declaration: {
6609    ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
6610    bool ForReferenceParam = Record[Idx++];
6611    return TemplateArgument(D, ForReferenceParam);
6612  }
6613  case TemplateArgument::NullPtr:
6614    return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
6615  case TemplateArgument::Integral: {
6616    llvm::APSInt Value = ReadAPSInt(Record, Idx);
6617    QualType T = readType(F, Record, Idx);
6618    return TemplateArgument(Context, Value, T);
6619  }
6620  case TemplateArgument::Template:
6621    return TemplateArgument(ReadTemplateName(F, Record, Idx));
6622  case TemplateArgument::TemplateExpansion: {
6623    TemplateName Name = ReadTemplateName(F, Record, Idx);
6624    Optional<unsigned> NumTemplateExpansions;
6625    if (unsigned NumExpansions = Record[Idx++])
6626      NumTemplateExpansions = NumExpansions - 1;
6627    return TemplateArgument(Name, NumTemplateExpansions);
6628  }
6629  case TemplateArgument::Expression:
6630    return TemplateArgument(ReadExpr(F));
6631  case TemplateArgument::Pack: {
6632    unsigned NumArgs = Record[Idx++];
6633    TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
6634    for (unsigned I = 0; I != NumArgs; ++I)
6635      Args[I] = ReadTemplateArgument(F, Record, Idx);
6636    return TemplateArgument(Args, NumArgs);
6637  }
6638  }
6639
6640  llvm_unreachable("Unhandled template argument kind!");
6641}
6642
6643TemplateParameterList *
6644ASTReader::ReadTemplateParameterList(ModuleFile &F,
6645                                     const RecordData &Record, unsigned &Idx) {
6646  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
6647  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
6648  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
6649
6650  unsigned NumParams = Record[Idx++];
6651  SmallVector<NamedDecl *, 16> Params;
6652  Params.reserve(NumParams);
6653  while (NumParams--)
6654    Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
6655
6656  TemplateParameterList* TemplateParams =
6657    TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
6658                                  Params.data(), Params.size(), RAngleLoc);
6659  return TemplateParams;
6660}
6661
6662void
6663ASTReader::
6664ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs,
6665                         ModuleFile &F, const RecordData &Record,
6666                         unsigned &Idx) {
6667  unsigned NumTemplateArgs = Record[Idx++];
6668  TemplArgs.reserve(NumTemplateArgs);
6669  while (NumTemplateArgs--)
6670    TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
6671}
6672
6673/// \brief Read a UnresolvedSet structure.
6674void ASTReader::ReadUnresolvedSet(ModuleFile &F, ASTUnresolvedSet &Set,
6675                                  const RecordData &Record, unsigned &Idx) {
6676  unsigned NumDecls = Record[Idx++];
6677  Set.reserve(Context, NumDecls);
6678  while (NumDecls--) {
6679    NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx);
6680    AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
6681    Set.addDecl(Context, D, AS);
6682  }
6683}
6684
6685CXXBaseSpecifier
6686ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
6687                                const RecordData &Record, unsigned &Idx) {
6688  bool isVirtual = static_cast<bool>(Record[Idx++]);
6689  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
6690  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
6691  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
6692  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
6693  SourceRange Range = ReadSourceRange(F, Record, Idx);
6694  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
6695  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
6696                          EllipsisLoc);
6697  Result.setInheritConstructors(inheritConstructors);
6698  return Result;
6699}
6700
6701std::pair<CXXCtorInitializer **, unsigned>
6702ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
6703                                   unsigned &Idx) {
6704  CXXCtorInitializer **CtorInitializers = 0;
6705  unsigned NumInitializers = Record[Idx++];
6706  if (NumInitializers) {
6707    CtorInitializers
6708        = new (Context) CXXCtorInitializer*[NumInitializers];
6709    for (unsigned i=0; i != NumInitializers; ++i) {
6710      TypeSourceInfo *TInfo = 0;
6711      bool IsBaseVirtual = false;
6712      FieldDecl *Member = 0;
6713      IndirectFieldDecl *IndirectMember = 0;
6714
6715      CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
6716      switch (Type) {
6717      case CTOR_INITIALIZER_BASE:
6718        TInfo = GetTypeSourceInfo(F, Record, Idx);
6719        IsBaseVirtual = Record[Idx++];
6720        break;
6721
6722      case CTOR_INITIALIZER_DELEGATING:
6723        TInfo = GetTypeSourceInfo(F, Record, Idx);
6724        break;
6725
6726       case CTOR_INITIALIZER_MEMBER:
6727        Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
6728        break;
6729
6730       case CTOR_INITIALIZER_INDIRECT_MEMBER:
6731        IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
6732        break;
6733      }
6734
6735      SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
6736      Expr *Init = ReadExpr(F);
6737      SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
6738      SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
6739      bool IsWritten = Record[Idx++];
6740      unsigned SourceOrderOrNumArrayIndices;
6741      SmallVector<VarDecl *, 8> Indices;
6742      if (IsWritten) {
6743        SourceOrderOrNumArrayIndices = Record[Idx++];
6744      } else {
6745        SourceOrderOrNumArrayIndices = Record[Idx++];
6746        Indices.reserve(SourceOrderOrNumArrayIndices);
6747        for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
6748          Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
6749      }
6750
6751      CXXCtorInitializer *BOMInit;
6752      if (Type == CTOR_INITIALIZER_BASE) {
6753        BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual,
6754                                             LParenLoc, Init, RParenLoc,
6755                                             MemberOrEllipsisLoc);
6756      } else if (Type == CTOR_INITIALIZER_DELEGATING) {
6757        BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc,
6758                                                   Init, RParenLoc);
6759      } else if (IsWritten) {
6760        if (Member)
6761          BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc,
6762                                               LParenLoc, Init, RParenLoc);
6763        else
6764          BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember,
6765                                               MemberOrEllipsisLoc, LParenLoc,
6766                                               Init, RParenLoc);
6767      } else {
6768        BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc,
6769                                             LParenLoc, Init, RParenLoc,
6770                                             Indices.data(), Indices.size());
6771      }
6772
6773      if (IsWritten)
6774        BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
6775      CtorInitializers[i] = BOMInit;
6776    }
6777  }
6778
6779  return std::make_pair(CtorInitializers, NumInitializers);
6780}
6781
6782NestedNameSpecifier *
6783ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
6784                                   const RecordData &Record, unsigned &Idx) {
6785  unsigned N = Record[Idx++];
6786  NestedNameSpecifier *NNS = 0, *Prev = 0;
6787  for (unsigned I = 0; I != N; ++I) {
6788    NestedNameSpecifier::SpecifierKind Kind
6789      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
6790    switch (Kind) {
6791    case NestedNameSpecifier::Identifier: {
6792      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
6793      NNS = NestedNameSpecifier::Create(Context, Prev, II);
6794      break;
6795    }
6796
6797    case NestedNameSpecifier::Namespace: {
6798      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
6799      NNS = NestedNameSpecifier::Create(Context, Prev, NS);
6800      break;
6801    }
6802
6803    case NestedNameSpecifier::NamespaceAlias: {
6804      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
6805      NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
6806      break;
6807    }
6808
6809    case NestedNameSpecifier::TypeSpec:
6810    case NestedNameSpecifier::TypeSpecWithTemplate: {
6811      const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
6812      if (!T)
6813        return 0;
6814
6815      bool Template = Record[Idx++];
6816      NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
6817      break;
6818    }
6819
6820    case NestedNameSpecifier::Global: {
6821      NNS = NestedNameSpecifier::GlobalSpecifier(Context);
6822      // No associated value, and there can't be a prefix.
6823      break;
6824    }
6825    }
6826    Prev = NNS;
6827  }
6828  return NNS;
6829}
6830
6831NestedNameSpecifierLoc
6832ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
6833                                      unsigned &Idx) {
6834  unsigned N = Record[Idx++];
6835  NestedNameSpecifierLocBuilder Builder;
6836  for (unsigned I = 0; I != N; ++I) {
6837    NestedNameSpecifier::SpecifierKind Kind
6838      = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
6839    switch (Kind) {
6840    case NestedNameSpecifier::Identifier: {
6841      IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
6842      SourceRange Range = ReadSourceRange(F, Record, Idx);
6843      Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
6844      break;
6845    }
6846
6847    case NestedNameSpecifier::Namespace: {
6848      NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
6849      SourceRange Range = ReadSourceRange(F, Record, Idx);
6850      Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
6851      break;
6852    }
6853
6854    case NestedNameSpecifier::NamespaceAlias: {
6855      NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
6856      SourceRange Range = ReadSourceRange(F, Record, Idx);
6857      Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
6858      break;
6859    }
6860
6861    case NestedNameSpecifier::TypeSpec:
6862    case NestedNameSpecifier::TypeSpecWithTemplate: {
6863      bool Template = Record[Idx++];
6864      TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
6865      if (!T)
6866        return NestedNameSpecifierLoc();
6867      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
6868
6869      // FIXME: 'template' keyword location not saved anywhere, so we fake it.
6870      Builder.Extend(Context,
6871                     Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
6872                     T->getTypeLoc(), ColonColonLoc);
6873      break;
6874    }
6875
6876    case NestedNameSpecifier::Global: {
6877      SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
6878      Builder.MakeGlobal(Context, ColonColonLoc);
6879      break;
6880    }
6881    }
6882  }
6883
6884  return Builder.getWithLocInContext(Context);
6885}
6886
6887SourceRange
6888ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
6889                           unsigned &Idx) {
6890  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
6891  SourceLocation end = ReadSourceLocation(F, Record, Idx);
6892  return SourceRange(beg, end);
6893}
6894
6895/// \brief Read an integral value
6896llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
6897  unsigned BitWidth = Record[Idx++];
6898  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
6899  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
6900  Idx += NumWords;
6901  return Result;
6902}
6903
6904/// \brief Read a signed integral value
6905llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
6906  bool isUnsigned = Record[Idx++];
6907  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
6908}
6909
6910/// \brief Read a floating-point value
6911llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
6912                                     const llvm::fltSemantics &Sem,
6913                                     unsigned &Idx) {
6914  return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
6915}
6916
6917// \brief Read a string
6918std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
6919  unsigned Len = Record[Idx++];
6920  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
6921  Idx += Len;
6922  return Result;
6923}
6924
6925VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
6926                                         unsigned &Idx) {
6927  unsigned Major = Record[Idx++];
6928  unsigned Minor = Record[Idx++];
6929  unsigned Subminor = Record[Idx++];
6930  if (Minor == 0)
6931    return VersionTuple(Major);
6932  if (Subminor == 0)
6933    return VersionTuple(Major, Minor - 1);
6934  return VersionTuple(Major, Minor - 1, Subminor - 1);
6935}
6936
6937CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
6938                                          const RecordData &Record,
6939                                          unsigned &Idx) {
6940  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
6941  return CXXTemporary::Create(Context, Decl);
6942}
6943
6944DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
6945  return Diag(SourceLocation(), DiagID);
6946}
6947
6948DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
6949  return Diags.Report(Loc, DiagID);
6950}
6951
6952/// \brief Retrieve the identifier table associated with the
6953/// preprocessor.
6954IdentifierTable &ASTReader::getIdentifierTable() {
6955  return PP.getIdentifierTable();
6956}
6957
6958/// \brief Record that the given ID maps to the given switch-case
6959/// statement.
6960void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
6961  assert((*CurrSwitchCaseStmts)[ID] == 0 &&
6962         "Already have a SwitchCase with this ID");
6963  (*CurrSwitchCaseStmts)[ID] = SC;
6964}
6965
6966/// \brief Retrieve the switch-case statement with the given ID.
6967SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
6968  assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID");
6969  return (*CurrSwitchCaseStmts)[ID];
6970}
6971
6972void ASTReader::ClearSwitchCaseIDs() {
6973  CurrSwitchCaseStmts->clear();
6974}
6975
6976void ASTReader::ReadComments() {
6977  std::vector<RawComment *> Comments;
6978  for (SmallVectorImpl<std::pair<BitstreamCursor,
6979                                 serialization::ModuleFile *> >::iterator
6980       I = CommentsCursors.begin(),
6981       E = CommentsCursors.end();
6982       I != E; ++I) {
6983    BitstreamCursor &Cursor = I->first;
6984    serialization::ModuleFile &F = *I->second;
6985    SavedStreamPosition SavedPosition(Cursor);
6986
6987    RecordData Record;
6988    while (true) {
6989      llvm::BitstreamEntry Entry =
6990        Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
6991
6992      switch (Entry.Kind) {
6993      case llvm::BitstreamEntry::SubBlock: // Handled for us already.
6994      case llvm::BitstreamEntry::Error:
6995        Error("malformed block record in AST file");
6996        return;
6997      case llvm::BitstreamEntry::EndBlock:
6998        goto NextCursor;
6999      case llvm::BitstreamEntry::Record:
7000        // The interesting case.
7001        break;
7002      }
7003
7004      // Read a record.
7005      Record.clear();
7006      switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
7007      case COMMENTS_RAW_COMMENT: {
7008        unsigned Idx = 0;
7009        SourceRange SR = ReadSourceRange(F, Record, Idx);
7010        RawComment::CommentKind Kind =
7011            (RawComment::CommentKind) Record[Idx++];
7012        bool IsTrailingComment = Record[Idx++];
7013        bool IsAlmostTrailingComment = Record[Idx++];
7014        Comments.push_back(new (Context) RawComment(SR, Kind,
7015                                                    IsTrailingComment,
7016                                                    IsAlmostTrailingComment));
7017        break;
7018      }
7019      }
7020    }
7021  NextCursor:;
7022  }
7023  Context.Comments.addCommentsToFront(Comments);
7024}
7025
7026void ASTReader::finishPendingActions() {
7027  while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty() ||
7028         !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty()) {
7029    // If any identifiers with corresponding top-level declarations have
7030    // been loaded, load those declarations now.
7031    llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> > TopLevelDecls;
7032    while (!PendingIdentifierInfos.empty()) {
7033      // FIXME: std::move
7034      IdentifierInfo *II = PendingIdentifierInfos.back().first;
7035      SmallVector<uint32_t, 4> DeclIDs = PendingIdentifierInfos.back().second;
7036      PendingIdentifierInfos.pop_back();
7037
7038      SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
7039    }
7040
7041    // Load pending declaration chains.
7042    for (unsigned I = 0; I != PendingDeclChains.size(); ++I) {
7043      loadPendingDeclChain(PendingDeclChains[I]);
7044      PendingDeclChainsKnown.erase(PendingDeclChains[I]);
7045    }
7046    PendingDeclChains.clear();
7047
7048    // Make the most recent of the top-level declarations visible.
7049    for (llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >::iterator
7050           TLD = TopLevelDecls.begin(), TLDEnd = TopLevelDecls.end();
7051         TLD != TLDEnd; ++TLD) {
7052      IdentifierInfo *II = TLD->first;
7053      for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
7054        NamedDecl *ND = cast<NamedDecl>(TLD->second[I]->getMostRecentDecl());
7055        SemaObj->pushExternalDeclIntoScope(ND, II);
7056      }
7057    }
7058
7059    // Load any pending macro definitions.
7060    for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
7061      // FIXME: std::move here
7062      SmallVector<MacroID, 2> GlobalIDs = PendingMacroIDs.begin()[I].second;
7063      MacroDirective *Hint = 0;
7064      for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx !=  NumIDs;
7065           ++IDIdx) {
7066        Hint = getMacro(GlobalIDs[IDIdx], Hint);
7067      }
7068    }
7069    PendingMacroIDs.clear();
7070
7071    // Wire up the DeclContexts for Decls that we delayed setting until
7072    // recursive loading is completed.
7073    while (!PendingDeclContextInfos.empty()) {
7074      PendingDeclContextInfo Info = PendingDeclContextInfos.front();
7075      PendingDeclContextInfos.pop_front();
7076      DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
7077      DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
7078      Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
7079    }
7080  }
7081
7082  // If we deserialized any C++ or Objective-C class definitions, any
7083  // Objective-C protocol definitions, or any redeclarable templates, make sure
7084  // that all redeclarations point to the definitions. Note that this can only
7085  // happen now, after the redeclaration chains have been fully wired.
7086  for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(),
7087                                           DEnd = PendingDefinitions.end();
7088       D != DEnd; ++D) {
7089    if (TagDecl *TD = dyn_cast<TagDecl>(*D)) {
7090      if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) {
7091        // Make sure that the TagType points at the definition.
7092        const_cast<TagType*>(TagT)->decl = TD;
7093      }
7094
7095      if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) {
7096        for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(),
7097                                         REnd = RD->redecls_end();
7098             R != REnd; ++R)
7099          cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData;
7100
7101      }
7102
7103      continue;
7104    }
7105
7106    if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) {
7107      // Make sure that the ObjCInterfaceType points at the definition.
7108      const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
7109        ->Decl = ID;
7110
7111      for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(),
7112                                           REnd = ID->redecls_end();
7113           R != REnd; ++R)
7114        R->Data = ID->Data;
7115
7116      continue;
7117    }
7118
7119    if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) {
7120      for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(),
7121                                          REnd = PD->redecls_end();
7122           R != REnd; ++R)
7123        R->Data = PD->Data;
7124
7125      continue;
7126    }
7127
7128    RedeclarableTemplateDecl *RTD
7129      = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl();
7130    for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(),
7131                                                REnd = RTD->redecls_end();
7132         R != REnd; ++R)
7133      R->Common = RTD->Common;
7134  }
7135  PendingDefinitions.clear();
7136
7137  // Load the bodies of any functions or methods we've encountered. We do
7138  // this now (delayed) so that we can be sure that the declaration chains
7139  // have been fully wired up.
7140  for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
7141                               PBEnd = PendingBodies.end();
7142       PB != PBEnd; ++PB) {
7143    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
7144      // FIXME: Check for =delete/=default?
7145      // FIXME: Complain about ODR violations here?
7146      if (!getContext().getLangOpts().Modules || !FD->hasBody())
7147        FD->setLazyBody(PB->second);
7148      continue;
7149    }
7150
7151    ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
7152    if (!getContext().getLangOpts().Modules || !MD->hasBody())
7153      MD->setLazyBody(PB->second);
7154  }
7155  PendingBodies.clear();
7156}
7157
7158void ASTReader::FinishedDeserializing() {
7159  assert(NumCurrentElementsDeserializing &&
7160         "FinishedDeserializing not paired with StartedDeserializing");
7161  if (NumCurrentElementsDeserializing == 1) {
7162    // We decrease NumCurrentElementsDeserializing only after pending actions
7163    // are finished, to avoid recursively re-calling finishPendingActions().
7164    finishPendingActions();
7165  }
7166  --NumCurrentElementsDeserializing;
7167
7168  if (NumCurrentElementsDeserializing == 0 &&
7169      Consumer && !PassingDeclsToConsumer) {
7170    // Guard variable to avoid recursively redoing the process of passing
7171    // decls to consumer.
7172    SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
7173                                                     true);
7174
7175    while (!InterestingDecls.empty()) {
7176      // We are not in recursive loading, so it's safe to pass the "interesting"
7177      // decls to the consumer.
7178      Decl *D = InterestingDecls.front();
7179      InterestingDecls.pop_front();
7180      PassInterestingDeclToConsumer(D);
7181    }
7182  }
7183}
7184
7185ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context,
7186                     StringRef isysroot, bool DisableValidation,
7187                     bool AllowASTWithCompilerErrors, bool UseGlobalIndex)
7188  : Listener(new PCHValidator(PP, *this)), DeserializationListener(0),
7189    SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
7190    Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context),
7191    Consumer(0), ModuleMgr(PP.getFileManager()),
7192    isysroot(isysroot), DisableValidation(DisableValidation),
7193    AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
7194    UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
7195    CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts),
7196    NumSLocEntriesRead(0), TotalNumSLocEntries(0),
7197    NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0),
7198    TotalNumMacros(0), NumIdentifierLookups(0), NumIdentifierLookupHits(0),
7199    NumSelectorsRead(0), NumMethodPoolEntriesRead(0),
7200    NumMethodPoolLookups(0), NumMethodPoolHits(0),
7201    NumMethodPoolTableLookups(0), NumMethodPoolTableHits(0),
7202    TotalNumMethodPoolEntries(0),
7203    NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
7204    NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
7205    TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
7206    PassingDeclsToConsumer(false),
7207    NumCXXBaseSpecifiersLoaded(0)
7208{
7209  SourceMgr.setExternalSLocEntrySource(this);
7210}
7211
7212ASTReader::~ASTReader() {
7213  for (DeclContextVisibleUpdatesPending::iterator
7214           I = PendingVisibleUpdates.begin(),
7215           E = PendingVisibleUpdates.end();
7216       I != E; ++I) {
7217    for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
7218                                             F = I->second.end();
7219         J != F; ++J)
7220      delete J->first;
7221  }
7222}
7223