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