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