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