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