clang  8.0.0svn
ASTReader.cpp
Go to the documentation of this file.
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 
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/Decl.h"
22 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/Expr.h"
30 #include "clang/AST/ExprCXX.h"
33 #include "clang/AST/ODRHash.h"
35 #include "clang/AST/TemplateBase.h"
36 #include "clang/AST/TemplateName.h"
37 #include "clang/AST/Type.h"
38 #include "clang/AST/TypeLoc.h"
42 #include "clang/Basic/Diagnostic.h"
48 #include "clang/Basic/LLVM.h"
51 #include "clang/Basic/Module.h"
55 #include "clang/Basic/Sanitizers.h"
59 #include "clang/Basic/Specifiers.h"
60 #include "clang/Basic/TargetInfo.h"
62 #include "clang/Basic/TokenKinds.h"
63 #include "clang/Basic/Version.h"
65 #include "clang/Lex/HeaderSearch.h"
67 #include "clang/Lex/MacroInfo.h"
68 #include "clang/Lex/ModuleMap.h"
70 #include "clang/Lex/Preprocessor.h"
72 #include "clang/Lex/Token.h"
74 #include "clang/Sema/Scope.h"
75 #include "clang/Sema/Sema.h"
76 #include "clang/Sema/Weak.h"
85 #include "llvm/ADT/APFloat.h"
86 #include "llvm/ADT/APInt.h"
87 #include "llvm/ADT/APSInt.h"
88 #include "llvm/ADT/ArrayRef.h"
89 #include "llvm/ADT/DenseMap.h"
90 #include "llvm/ADT/FoldingSet.h"
91 #include "llvm/ADT/Hashing.h"
92 #include "llvm/ADT/IntrusiveRefCntPtr.h"
93 #include "llvm/ADT/None.h"
94 #include "llvm/ADT/Optional.h"
95 #include "llvm/ADT/STLExtras.h"
96 #include "llvm/ADT/SmallPtrSet.h"
97 #include "llvm/ADT/SmallString.h"
98 #include "llvm/ADT/SmallVector.h"
99 #include "llvm/ADT/StringExtras.h"
100 #include "llvm/ADT/StringMap.h"
101 #include "llvm/ADT/StringRef.h"
102 #include "llvm/ADT/Triple.h"
103 #include "llvm/ADT/iterator_range.h"
104 #include "llvm/Bitcode/BitstreamReader.h"
105 #include "llvm/Support/Casting.h"
106 #include "llvm/Support/Compiler.h"
107 #include "llvm/Support/Compression.h"
108 #include "llvm/Support/DJB.h"
109 #include "llvm/Support/Endian.h"
110 #include "llvm/Support/Error.h"
111 #include "llvm/Support/ErrorHandling.h"
112 #include "llvm/Support/FileSystem.h"
113 #include "llvm/Support/MemoryBuffer.h"
114 #include "llvm/Support/Path.h"
115 #include "llvm/Support/SaveAndRestore.h"
116 #include "llvm/Support/Timer.h"
117 #include "llvm/Support/VersionTuple.h"
118 #include "llvm/Support/raw_ostream.h"
119 #include <algorithm>
120 #include <cassert>
121 #include <cstddef>
122 #include <cstdint>
123 #include <cstdio>
124 #include <ctime>
125 #include <iterator>
126 #include <limits>
127 #include <map>
128 #include <memory>
129 #include <string>
130 #include <system_error>
131 #include <tuple>
132 #include <utility>
133 #include <vector>
134 
135 using namespace clang;
136 using namespace clang::serialization;
137 using namespace clang::serialization::reader;
138 using llvm::BitstreamCursor;
139 
140 //===----------------------------------------------------------------------===//
141 // ChainedASTReaderListener implementation
142 //===----------------------------------------------------------------------===//
143 
144 bool
146  return First->ReadFullVersionInformation(FullVersion) ||
147  Second->ReadFullVersionInformation(FullVersion);
148 }
149 
150 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
151  First->ReadModuleName(ModuleName);
152  Second->ReadModuleName(ModuleName);
153 }
154 
155 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
156  First->ReadModuleMapFile(ModuleMapPath);
157  Second->ReadModuleMapFile(ModuleMapPath);
158 }
159 
160 bool
162  bool Complain,
163  bool AllowCompatibleDifferences) {
164  return First->ReadLanguageOptions(LangOpts, Complain,
165  AllowCompatibleDifferences) ||
166  Second->ReadLanguageOptions(LangOpts, Complain,
167  AllowCompatibleDifferences);
168 }
169 
171  const TargetOptions &TargetOpts, bool Complain,
172  bool AllowCompatibleDifferences) {
173  return First->ReadTargetOptions(TargetOpts, Complain,
174  AllowCompatibleDifferences) ||
175  Second->ReadTargetOptions(TargetOpts, Complain,
176  AllowCompatibleDifferences);
177 }
178 
180  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
181  return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
182  Second->ReadDiagnosticOptions(DiagOpts, Complain);
183 }
184 
185 bool
187  bool Complain) {
188  return First->ReadFileSystemOptions(FSOpts, Complain) ||
189  Second->ReadFileSystemOptions(FSOpts, Complain);
190 }
191 
193  const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
194  bool Complain) {
195  return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
196  Complain) ||
197  Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
198  Complain);
199 }
200 
202  const PreprocessorOptions &PPOpts, bool Complain,
203  std::string &SuggestedPredefines) {
204  return First->ReadPreprocessorOptions(PPOpts, Complain,
205  SuggestedPredefines) ||
206  Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
207 }
208 
210  unsigned Value) {
211  First->ReadCounter(M, Value);
212  Second->ReadCounter(M, Value);
213 }
214 
216  return First->needsInputFileVisitation() ||
217  Second->needsInputFileVisitation();
218 }
219 
221  return First->needsSystemInputFileVisitation() ||
222  Second->needsSystemInputFileVisitation();
223 }
224 
226  ModuleKind Kind) {
227  First->visitModuleFile(Filename, Kind);
228  Second->visitModuleFile(Filename, Kind);
229 }
230 
232  bool isSystem,
233  bool isOverridden,
234  bool isExplicitModule) {
235  bool Continue = false;
236  if (First->needsInputFileVisitation() &&
237  (!isSystem || First->needsSystemInputFileVisitation()))
238  Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
239  isExplicitModule);
240  if (Second->needsInputFileVisitation() &&
241  (!isSystem || Second->needsSystemInputFileVisitation()))
242  Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
243  isExplicitModule);
244  return Continue;
245 }
246 
248  const ModuleFileExtensionMetadata &Metadata) {
249  First->readModuleFileExtension(Metadata);
250  Second->readModuleFileExtension(Metadata);
251 }
252 
253 //===----------------------------------------------------------------------===//
254 // PCH validator implementation
255 //===----------------------------------------------------------------------===//
256 
258 
259 /// Compare the given set of language options against an existing set of
260 /// language options.
261 ///
262 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
263 /// \param AllowCompatibleDifferences If true, differences between compatible
264 /// language options will be permitted.
265 ///
266 /// \returns true if the languagae options mis-match, false otherwise.
267 static bool checkLanguageOptions(const LangOptions &LangOpts,
268  const LangOptions &ExistingLangOpts,
269  DiagnosticsEngine *Diags,
270  bool AllowCompatibleDifferences = true) {
271 #define LANGOPT(Name, Bits, Default, Description) \
272  if (ExistingLangOpts.Name != LangOpts.Name) { \
273  if (Diags) \
274  Diags->Report(diag::err_pch_langopt_mismatch) \
275  << Description << LangOpts.Name << ExistingLangOpts.Name; \
276  return true; \
277  }
278 
279 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
280  if (ExistingLangOpts.Name != LangOpts.Name) { \
281  if (Diags) \
282  Diags->Report(diag::err_pch_langopt_value_mismatch) \
283  << Description; \
284  return true; \
285  }
286 
287 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
288  if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
289  if (Diags) \
290  Diags->Report(diag::err_pch_langopt_value_mismatch) \
291  << Description; \
292  return true; \
293  }
294 
295 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
296  if (!AllowCompatibleDifferences) \
297  LANGOPT(Name, Bits, Default, Description)
298 
299 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
300  if (!AllowCompatibleDifferences) \
301  ENUM_LANGOPT(Name, Bits, Default, Description)
302 
303 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
304  if (!AllowCompatibleDifferences) \
305  VALUE_LANGOPT(Name, Bits, Default, Description)
306 
307 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
308 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
309 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
310 #include "clang/Basic/LangOptions.def"
311 
312  if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
313  if (Diags)
314  Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
315  return true;
316  }
317 
318  if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
319  if (Diags)
320  Diags->Report(diag::err_pch_langopt_value_mismatch)
321  << "target Objective-C runtime";
322  return true;
323  }
324 
325  if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
326  LangOpts.CommentOpts.BlockCommandNames) {
327  if (Diags)
328  Diags->Report(diag::err_pch_langopt_value_mismatch)
329  << "block command names";
330  return true;
331  }
332 
333  // Sanitizer feature mismatches are treated as compatible differences. If
334  // compatible differences aren't allowed, we still only want to check for
335  // mismatches of non-modular sanitizers (the only ones which can affect AST
336  // generation).
337  if (!AllowCompatibleDifferences) {
338  SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
339  SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
340  SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
341  ExistingSanitizers.clear(ModularSanitizers);
342  ImportedSanitizers.clear(ModularSanitizers);
343  if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
344  const std::string Flag = "-fsanitize=";
345  if (Diags) {
346 #define SANITIZER(NAME, ID) \
347  { \
348  bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
349  bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
350  if (InExistingModule != InImportedModule) \
351  Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
352  << InExistingModule << (Flag + NAME); \
353  }
354 #include "clang/Basic/Sanitizers.def"
355  }
356  return true;
357  }
358  }
359 
360  return false;
361 }
362 
363 /// Compare the given set of target options against an existing set of
364 /// target options.
365 ///
366 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
367 ///
368 /// \returns true if the target options mis-match, false otherwise.
369 static bool checkTargetOptions(const TargetOptions &TargetOpts,
370  const TargetOptions &ExistingTargetOpts,
371  DiagnosticsEngine *Diags,
372  bool AllowCompatibleDifferences = true) {
373 #define CHECK_TARGET_OPT(Field, Name) \
374  if (TargetOpts.Field != ExistingTargetOpts.Field) { \
375  if (Diags) \
376  Diags->Report(diag::err_pch_targetopt_mismatch) \
377  << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
378  return true; \
379  }
380 
381  // The triple and ABI must match exactly.
382  CHECK_TARGET_OPT(Triple, "target");
383  CHECK_TARGET_OPT(ABI, "target ABI");
384 
385  // We can tolerate different CPUs in many cases, notably when one CPU
386  // supports a strict superset of another. When allowing compatible
387  // differences skip this check.
388  if (!AllowCompatibleDifferences)
389  CHECK_TARGET_OPT(CPU, "target CPU");
390 
391 #undef CHECK_TARGET_OPT
392 
393  // Compare feature sets.
394  SmallVector<StringRef, 4> ExistingFeatures(
395  ExistingTargetOpts.FeaturesAsWritten.begin(),
396  ExistingTargetOpts.FeaturesAsWritten.end());
397  SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
398  TargetOpts.FeaturesAsWritten.end());
399  llvm::sort(ExistingFeatures);
400  llvm::sort(ReadFeatures);
401 
402  // We compute the set difference in both directions explicitly so that we can
403  // diagnose the differences differently.
404  SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
405  std::set_difference(
406  ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
407  ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
408  std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
409  ExistingFeatures.begin(), ExistingFeatures.end(),
410  std::back_inserter(UnmatchedReadFeatures));
411 
412  // If we are allowing compatible differences and the read feature set is
413  // a strict subset of the existing feature set, there is nothing to diagnose.
414  if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
415  return false;
416 
417  if (Diags) {
418  for (StringRef Feature : UnmatchedReadFeatures)
419  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
420  << /* is-existing-feature */ false << Feature;
421  for (StringRef Feature : UnmatchedExistingFeatures)
422  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
423  << /* is-existing-feature */ true << Feature;
424  }
425 
426  return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
427 }
428 
429 bool
431  bool Complain,
432  bool AllowCompatibleDifferences) {
433  const LangOptions &ExistingLangOpts = PP.getLangOpts();
434  return checkLanguageOptions(LangOpts, ExistingLangOpts,
435  Complain ? &Reader.Diags : nullptr,
436  AllowCompatibleDifferences);
437 }
438 
440  bool Complain,
441  bool AllowCompatibleDifferences) {
442  const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
443  return checkTargetOptions(TargetOpts, ExistingTargetOpts,
444  Complain ? &Reader.Diags : nullptr,
445  AllowCompatibleDifferences);
446 }
447 
448 namespace {
449 
450 using MacroDefinitionsMap =
451  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
452 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
453 
454 } // namespace
455 
457  DiagnosticsEngine &Diags,
458  bool Complain) {
460 
461  // Check current mappings for new -Werror mappings, and the stored mappings
462  // for cases that were explicitly mapped to *not* be errors that are now
463  // errors because of options like -Werror.
464  DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
465 
466  for (DiagnosticsEngine *MappingSource : MappingSources) {
467  for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
468  diag::kind DiagID = DiagIDMappingPair.first;
469  Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
470  if (CurLevel < DiagnosticsEngine::Error)
471  continue; // not significant
472  Level StoredLevel =
473  StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
474  if (StoredLevel < DiagnosticsEngine::Error) {
475  if (Complain)
476  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
477  Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
478  return true;
479  }
480  }
481  }
482 
483  return false;
484 }
485 
488  if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
489  return true;
490  return Ext >= diag::Severity::Error;
491 }
492 
494  DiagnosticsEngine &Diags,
495  bool IsSystem, bool Complain) {
496  // Top-level options
497  if (IsSystem) {
498  if (Diags.getSuppressSystemWarnings())
499  return false;
500  // If -Wsystem-headers was not enabled before, be conservative
501  if (StoredDiags.getSuppressSystemWarnings()) {
502  if (Complain)
503  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
504  return true;
505  }
506  }
507 
508  if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
509  if (Complain)
510  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
511  return true;
512  }
513 
514  if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
515  !StoredDiags.getEnableAllWarnings()) {
516  if (Complain)
517  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
518  return true;
519  }
520 
521  if (isExtHandlingFromDiagsError(Diags) &&
522  !isExtHandlingFromDiagsError(StoredDiags)) {
523  if (Complain)
524  Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
525  return true;
526  }
527 
528  return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
529 }
530 
531 /// Return the top import module if it is implicit, nullptr otherwise.
533  Preprocessor &PP) {
534  // If the original import came from a file explicitly generated by the user,
535  // don't check the diagnostic mappings.
536  // FIXME: currently this is approximated by checking whether this is not a
537  // module import of an implicitly-loaded module file.
538  // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
539  // the transitive closure of its imports, since unrelated modules cannot be
540  // imported until after this module finishes validation.
541  ModuleFile *TopImport = &*ModuleMgr.rbegin();
542  while (!TopImport->ImportedBy.empty())
543  TopImport = TopImport->ImportedBy[0];
544  if (TopImport->Kind != MK_ImplicitModule)
545  return nullptr;
546 
547  StringRef ModuleName = TopImport->ModuleName;
548  assert(!ModuleName.empty() && "diagnostic options read before module name");
549 
550  Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
551  assert(M && "missing module");
552  return M;
553 }
554 
556  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
557  DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
558  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
560  new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
561  // This should never fail, because we would have processed these options
562  // before writing them to an ASTFile.
563  ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
564 
565  ModuleManager &ModuleMgr = Reader.getModuleManager();
566  assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
567 
568  Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
569  if (!TopM)
570  return false;
571 
572  // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
573  // contains the union of their flags.
574  return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
575  Complain);
576 }
577 
578 /// Collect the macro definitions provided by the given preprocessor
579 /// options.
580 static void
582  MacroDefinitionsMap &Macros,
583  SmallVectorImpl<StringRef> *MacroNames = nullptr) {
584  for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
585  StringRef Macro = PPOpts.Macros[I].first;
586  bool IsUndef = PPOpts.Macros[I].second;
587 
588  std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
589  StringRef MacroName = MacroPair.first;
590  StringRef MacroBody = MacroPair.second;
591 
592  // For an #undef'd macro, we only care about the name.
593  if (IsUndef) {
594  if (MacroNames && !Macros.count(MacroName))
595  MacroNames->push_back(MacroName);
596 
597  Macros[MacroName] = std::make_pair("", true);
598  continue;
599  }
600 
601  // For a #define'd macro, figure out the actual definition.
602  if (MacroName.size() == Macro.size())
603  MacroBody = "1";
604  else {
605  // Note: GCC drops anything following an end-of-line character.
606  StringRef::size_type End = MacroBody.find_first_of("\n\r");
607  MacroBody = MacroBody.substr(0, End);
608  }
609 
610  if (MacroNames && !Macros.count(MacroName))
611  MacroNames->push_back(MacroName);
612  Macros[MacroName] = std::make_pair(MacroBody, false);
613  }
614 }
615 
616 /// Check the preprocessor options deserialized from the control block
617 /// against the preprocessor options in an existing preprocessor.
618 ///
619 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620 /// \param Validate If true, validate preprocessor options. If false, allow
621 /// macros defined by \p ExistingPPOpts to override those defined by
622 /// \p PPOpts in SuggestedPredefines.
624  const PreprocessorOptions &ExistingPPOpts,
625  DiagnosticsEngine *Diags,
626  FileManager &FileMgr,
627  std::string &SuggestedPredefines,
628  const LangOptions &LangOpts,
629  bool Validate = true) {
630  // Check macro definitions.
631  MacroDefinitionsMap ASTFileMacros;
632  collectMacroDefinitions(PPOpts, ASTFileMacros);
633  MacroDefinitionsMap ExistingMacros;
634  SmallVector<StringRef, 4> ExistingMacroNames;
635  collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
636 
637  for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
638  // Dig out the macro definition in the existing preprocessor options.
639  StringRef MacroName = ExistingMacroNames[I];
640  std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
641 
642  // Check whether we know anything about this macro name or not.
643  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
644  ASTFileMacros.find(MacroName);
645  if (!Validate || Known == ASTFileMacros.end()) {
646  // FIXME: Check whether this identifier was referenced anywhere in the
647  // AST file. If so, we should reject the AST file. Unfortunately, this
648  // information isn't in the control block. What shall we do about it?
649 
650  if (Existing.second) {
651  SuggestedPredefines += "#undef ";
652  SuggestedPredefines += MacroName.str();
653  SuggestedPredefines += '\n';
654  } else {
655  SuggestedPredefines += "#define ";
656  SuggestedPredefines += MacroName.str();
657  SuggestedPredefines += ' ';
658  SuggestedPredefines += Existing.first.str();
659  SuggestedPredefines += '\n';
660  }
661  continue;
662  }
663 
664  // If the macro was defined in one but undef'd in the other, we have a
665  // conflict.
666  if (Existing.second != Known->second.second) {
667  if (Diags) {
668  Diags->Report(diag::err_pch_macro_def_undef)
669  << MacroName << Known->second.second;
670  }
671  return true;
672  }
673 
674  // If the macro was #undef'd in both, or if the macro bodies are identical,
675  // it's fine.
676  if (Existing.second || Existing.first == Known->second.first)
677  continue;
678 
679  // The macro bodies differ; complain.
680  if (Diags) {
681  Diags->Report(diag::err_pch_macro_def_conflict)
682  << MacroName << Known->second.first << Existing.first;
683  }
684  return true;
685  }
686 
687  // Check whether we're using predefines.
688  if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
689  if (Diags) {
690  Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
691  }
692  return true;
693  }
694 
695  // Detailed record is important since it is used for the module cache hash.
696  if (LangOpts.Modules &&
697  PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
698  if (Diags) {
699  Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
700  }
701  return true;
702  }
703 
704  // Compute the #include and #include_macros lines we need.
705  for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
706  StringRef File = ExistingPPOpts.Includes[I];
707 
708  if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
709  !ExistingPPOpts.PCHThroughHeader.empty()) {
710  // In case the through header is an include, we must add all the includes
711  // to the predefines so the start point can be determined.
712  SuggestedPredefines += "#include \"";
713  SuggestedPredefines += File;
714  SuggestedPredefines += "\"\n";
715  continue;
716  }
717 
718  if (File == ExistingPPOpts.ImplicitPCHInclude)
719  continue;
720 
721  if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
722  != PPOpts.Includes.end())
723  continue;
724 
725  SuggestedPredefines += "#include \"";
726  SuggestedPredefines += File;
727  SuggestedPredefines += "\"\n";
728  }
729 
730  for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
731  StringRef File = ExistingPPOpts.MacroIncludes[I];
732  if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
733  File)
734  != PPOpts.MacroIncludes.end())
735  continue;
736 
737  SuggestedPredefines += "#__include_macros \"";
738  SuggestedPredefines += File;
739  SuggestedPredefines += "\"\n##\n";
740  }
741 
742  return false;
743 }
744 
746  bool Complain,
747  std::string &SuggestedPredefines) {
748  const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
749 
750  return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
751  Complain? &Reader.Diags : nullptr,
752  PP.getFileManager(),
753  SuggestedPredefines,
754  PP.getLangOpts());
755 }
756 
758  const PreprocessorOptions &PPOpts,
759  bool Complain,
760  std::string &SuggestedPredefines) {
761  return checkPreprocessorOptions(PPOpts,
762  PP.getPreprocessorOpts(),
763  nullptr,
764  PP.getFileManager(),
765  SuggestedPredefines,
766  PP.getLangOpts(),
767  false);
768 }
769 
770 /// Check the header search options deserialized from the control block
771 /// against the header search options in an existing preprocessor.
772 ///
773 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
775  StringRef SpecificModuleCachePath,
776  StringRef ExistingModuleCachePath,
777  DiagnosticsEngine *Diags,
778  const LangOptions &LangOpts) {
779  if (LangOpts.Modules) {
780  if (SpecificModuleCachePath != ExistingModuleCachePath) {
781  if (Diags)
782  Diags->Report(diag::err_pch_modulecache_mismatch)
783  << SpecificModuleCachePath << ExistingModuleCachePath;
784  return true;
785  }
786  }
787 
788  return false;
789 }
790 
792  StringRef SpecificModuleCachePath,
793  bool Complain) {
794  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
795  PP.getHeaderSearchInfo().getModuleCachePath(),
796  Complain ? &Reader.Diags : nullptr,
797  PP.getLangOpts());
798 }
799 
800 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
801  PP.setCounterValue(Value);
802 }
803 
804 //===----------------------------------------------------------------------===//
805 // AST reader implementation
806 //===----------------------------------------------------------------------===//
807 
809  bool TakeOwnership) {
810  DeserializationListener = Listener;
811  OwnsDeserializationListener = TakeOwnership;
812 }
813 
815  return serialization::ComputeHash(Sel);
816 }
817 
818 std::pair<unsigned, unsigned>
820  using namespace llvm::support;
821 
822  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
823  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
824  return std::make_pair(KeyLen, DataLen);
825 }
826 
828 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
829  using namespace llvm::support;
830 
831  SelectorTable &SelTable = Reader.getContext().Selectors;
832  unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
833  IdentifierInfo *FirstII = Reader.getLocalIdentifier(
834  F, endian::readNext<uint32_t, little, unaligned>(d));
835  if (N == 0)
836  return SelTable.getNullarySelector(FirstII);
837  else if (N == 1)
838  return SelTable.getUnarySelector(FirstII);
839 
841  Args.push_back(FirstII);
842  for (unsigned I = 1; I != N; ++I)
843  Args.push_back(Reader.getLocalIdentifier(
844  F, endian::readNext<uint32_t, little, unaligned>(d)));
845 
846  return SelTable.getSelector(N, Args.data());
847 }
848 
851  unsigned DataLen) {
852  using namespace llvm::support;
853 
854  data_type Result;
855 
856  Result.ID = Reader.getGlobalSelectorID(
857  F, endian::readNext<uint32_t, little, unaligned>(d));
858  unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
859  unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
860  Result.InstanceBits = FullInstanceBits & 0x3;
861  Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
862  Result.FactoryBits = FullFactoryBits & 0x3;
863  Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
864  unsigned NumInstanceMethods = FullInstanceBits >> 3;
865  unsigned NumFactoryMethods = FullFactoryBits >> 3;
866 
867  // Load instance methods
868  for (unsigned I = 0; I != NumInstanceMethods; ++I) {
869  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
870  F, endian::readNext<uint32_t, little, unaligned>(d)))
871  Result.Instance.push_back(Method);
872  }
873 
874  // Load factory methods
875  for (unsigned I = 0; I != NumFactoryMethods; ++I) {
876  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
877  F, endian::readNext<uint32_t, little, unaligned>(d)))
878  Result.Factory.push_back(Method);
879  }
880 
881  return Result;
882 }
883 
885  return llvm::djbHash(a);
886 }
887 
888 std::pair<unsigned, unsigned>
890  using namespace llvm::support;
891 
892  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
893  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
894  return std::make_pair(KeyLen, DataLen);
895 }
896 
898 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
899  assert(n >= 2 && d[n-1] == '\0');
900  return StringRef((const char*) d, n-1);
901 }
902 
903 /// Whether the given identifier is "interesting".
905  bool IsModule) {
906  return II.hadMacroDefinition() ||
907  II.isPoisoned() ||
908  (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
910  (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
911  II.getFETokenInfo());
912 }
913 
914 static bool readBit(unsigned &Bits) {
915  bool Value = Bits & 0x1;
916  Bits >>= 1;
917  return Value;
918 }
919 
921  using namespace llvm::support;
922 
923  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
924  return Reader.getGlobalIdentifierID(F, RawID >> 1);
925 }
926 
927 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
928  if (!II.isFromAST()) {
929  II.setIsFromAST();
930  bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
931  if (isInterestingIdentifier(Reader, II, IsModule))
933  }
934 }
935 
937  const unsigned char* d,
938  unsigned DataLen) {
939  using namespace llvm::support;
940 
941  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
942  bool IsInteresting = RawID & 0x01;
943 
944  // Wipe out the "is interesting" bit.
945  RawID = RawID >> 1;
946 
947  // Build the IdentifierInfo and link the identifier ID with it.
948  IdentifierInfo *II = KnownII;
949  if (!II) {
950  II = &Reader.getIdentifierTable().getOwn(k);
951  KnownII = II;
952  }
953  markIdentifierFromAST(Reader, *II);
954  Reader.markIdentifierUpToDate(II);
955 
956  IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
957  if (!IsInteresting) {
958  // For uninteresting identifiers, there's nothing else to do. Just notify
959  // the reader that we've finished loading this identifier.
960  Reader.SetIdentifierInfo(ID, II);
961  return II;
962  }
963 
964  unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
965  unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
966  bool CPlusPlusOperatorKeyword = readBit(Bits);
967  bool HasRevertedTokenIDToIdentifier = readBit(Bits);
968  bool HasRevertedBuiltin = readBit(Bits);
969  bool Poisoned = readBit(Bits);
970  bool ExtensionToken = readBit(Bits);
971  bool HadMacroDefinition = readBit(Bits);
972 
973  assert(Bits == 0 && "Extra bits in the identifier?");
974  DataLen -= 8;
975 
976  // Set or check the various bits in the IdentifierInfo structure.
977  // Token IDs are read-only.
978  if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
980  if (!F.isModule())
981  II->setObjCOrBuiltinID(ObjCOrBuiltinID);
982  else if (HasRevertedBuiltin && II->getBuiltinID()) {
983  II->revertBuiltin();
984  assert((II->hasRevertedBuiltin() ||
985  II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
986  "Incorrect ObjC keyword or builtin ID");
987  }
988  assert(II->isExtensionToken() == ExtensionToken &&
989  "Incorrect extension token flag");
990  (void)ExtensionToken;
991  if (Poisoned)
992  II->setIsPoisoned(true);
993  assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
994  "Incorrect C++ operator keyword flag");
995  (void)CPlusPlusOperatorKeyword;
996 
997  // If this identifier is a macro, deserialize the macro
998  // definition.
999  if (HadMacroDefinition) {
1000  uint32_t MacroDirectivesOffset =
1001  endian::readNext<uint32_t, little, unaligned>(d);
1002  DataLen -= 4;
1003 
1004  Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1005  }
1006 
1007  Reader.SetIdentifierInfo(ID, II);
1008 
1009  // Read all of the declarations visible at global scope with this
1010  // name.
1011  if (DataLen > 0) {
1012  SmallVector<uint32_t, 4> DeclIDs;
1013  for (; DataLen > 0; DataLen -= 4)
1014  DeclIDs.push_back(Reader.getGlobalDeclID(
1015  F, endian::readNext<uint32_t, little, unaligned>(d)));
1016  Reader.SetGloballyVisibleDecls(II, DeclIDs);
1017  }
1018 
1019  return II;
1020 }
1021 
1023  : Kind(Name.getNameKind()) {
1024  switch (Kind) {
1026  Data = (uint64_t)Name.getAsIdentifierInfo();
1027  break;
1031  Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1032  break;
1034  Data = Name.getCXXOverloadedOperator();
1035  break;
1037  Data = (uint64_t)Name.getCXXLiteralIdentifier();
1038  break;
1040  Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1042  break;
1047  Data = 0;
1048  break;
1049  }
1050 }
1051 
1053  llvm::FoldingSetNodeID ID;
1054  ID.AddInteger(Kind);
1055 
1056  switch (Kind) {
1060  ID.AddString(((IdentifierInfo*)Data)->getName());
1061  break;
1065  ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1066  break;
1068  ID.AddInteger((OverloadedOperatorKind)Data);
1069  break;
1074  break;
1075  }
1076 
1077  return ID.ComputeHash();
1078 }
1079 
1080 ModuleFile *
1081 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1082  using namespace llvm::support;
1083 
1084  uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1085  return Reader.getLocalModuleFile(F, ModuleFileID);
1086 }
1087 
1088 std::pair<unsigned, unsigned>
1089 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1090  using namespace llvm::support;
1091 
1092  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1093  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1094  return std::make_pair(KeyLen, DataLen);
1095 }
1096 
1098 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1099  using namespace llvm::support;
1100 
1101  auto Kind = (DeclarationName::NameKind)*d++;
1102  uint64_t Data;
1103  switch (Kind) {
1107  Data = (uint64_t)Reader.getLocalIdentifier(
1108  F, endian::readNext<uint32_t, little, unaligned>(d));
1109  break;
1113  Data =
1114  (uint64_t)Reader.getLocalSelector(
1115  F, endian::readNext<uint32_t, little, unaligned>(
1116  d)).getAsOpaquePtr();
1117  break;
1119  Data = *d++; // OverloadedOperatorKind
1120  break;
1125  Data = 0;
1126  break;
1127  }
1128 
1129  return DeclarationNameKey(Kind, Data);
1130 }
1131 
1132 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1133  const unsigned char *d,
1134  unsigned DataLen,
1135  data_type_builder &Val) {
1136  using namespace llvm::support;
1137 
1138  for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1139  uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1140  Val.insert(Reader.getGlobalDeclID(F, LocalID));
1141  }
1142 }
1143 
1144 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1145  BitstreamCursor &Cursor,
1146  uint64_t Offset,
1147  DeclContext *DC) {
1148  assert(Offset != 0);
1149 
1150  SavedStreamPosition SavedPosition(Cursor);
1151  Cursor.JumpToBit(Offset);
1152 
1153  RecordData Record;
1154  StringRef Blob;
1155  unsigned Code = Cursor.ReadCode();
1156  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1157  if (RecCode != DECL_CONTEXT_LEXICAL) {
1158  Error("Expected lexical block");
1159  return true;
1160  }
1161 
1162  assert(!isa<TranslationUnitDecl>(DC) &&
1163  "expected a TU_UPDATE_LEXICAL record for TU");
1164  // If we are handling a C++ class template instantiation, we can see multiple
1165  // lexical updates for the same record. It's important that we select only one
1166  // of them, so that field numbering works properly. Just pick the first one we
1167  // see.
1168  auto &Lex = LexicalDecls[DC];
1169  if (!Lex.first) {
1170  Lex = std::make_pair(
1171  &M, llvm::makeArrayRef(
1172  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1173  Blob.data()),
1174  Blob.size() / 4));
1175  }
1176  DC->setHasExternalLexicalStorage(true);
1177  return false;
1178 }
1179 
1180 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1181  BitstreamCursor &Cursor,
1182  uint64_t Offset,
1183  DeclID ID) {
1184  assert(Offset != 0);
1185 
1186  SavedStreamPosition SavedPosition(Cursor);
1187  Cursor.JumpToBit(Offset);
1188 
1189  RecordData Record;
1190  StringRef Blob;
1191  unsigned Code = Cursor.ReadCode();
1192  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1193  if (RecCode != DECL_CONTEXT_VISIBLE) {
1194  Error("Expected visible lookup table block");
1195  return true;
1196  }
1197 
1198  // We can't safely determine the primary context yet, so delay attaching the
1199  // lookup table until we're done with recursive deserialization.
1200  auto *Data = (const unsigned char*)Blob.data();
1201  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1202  return false;
1203 }
1204 
1205 void ASTReader::Error(StringRef Msg) const {
1206  Error(diag::err_fe_pch_malformed, Msg);
1207  if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1208  !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1209  Diag(diag::note_module_cache_path)
1210  << PP.getHeaderSearchInfo().getModuleCachePath();
1211  }
1212 }
1213 
1214 void ASTReader::Error(unsigned DiagID,
1215  StringRef Arg1, StringRef Arg2) const {
1216  if (Diags.isDiagnosticInFlight())
1217  Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1218  else
1219  Diag(DiagID) << Arg1 << Arg2;
1220 }
1221 
1222 //===----------------------------------------------------------------------===//
1223 // Source Manager Deserialization
1224 //===----------------------------------------------------------------------===//
1225 
1226 /// Read the line table in the source manager block.
1227 /// \returns true if there was an error.
1228 bool ASTReader::ParseLineTable(ModuleFile &F,
1229  const RecordData &Record) {
1230  unsigned Idx = 0;
1231  LineTableInfo &LineTable = SourceMgr.getLineTable();
1232 
1233  // Parse the file names
1234  std::map<int, int> FileIDs;
1235  FileIDs[-1] = -1; // For unspecified filenames.
1236  for (unsigned I = 0; Record[Idx]; ++I) {
1237  // Extract the file name
1238  auto Filename = ReadPath(F, Record, Idx);
1239  FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1240  }
1241  ++Idx;
1242 
1243  // Parse the line entries
1244  std::vector<LineEntry> Entries;
1245  while (Idx < Record.size()) {
1246  int FID = Record[Idx++];
1247  assert(FID >= 0 && "Serialized line entries for non-local file.");
1248  // Remap FileID from 1-based old view.
1249  FID += F.SLocEntryBaseID - 1;
1250 
1251  // Extract the line entries
1252  unsigned NumEntries = Record[Idx++];
1253  assert(NumEntries && "no line entries for file ID");
1254  Entries.clear();
1255  Entries.reserve(NumEntries);
1256  for (unsigned I = 0; I != NumEntries; ++I) {
1257  unsigned FileOffset = Record[Idx++];
1258  unsigned LineNo = Record[Idx++];
1259  int FilenameID = FileIDs[Record[Idx++]];
1261  = (SrcMgr::CharacteristicKind)Record[Idx++];
1262  unsigned IncludeOffset = Record[Idx++];
1263  Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1264  FileKind, IncludeOffset));
1265  }
1266  LineTable.AddEntry(FileID::get(FID), Entries);
1267  }
1268 
1269  return false;
1270 }
1271 
1272 /// Read a source manager block
1273 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1274  using namespace SrcMgr;
1275 
1276  BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1277 
1278  // Set the source-location entry cursor to the current position in
1279  // the stream. This cursor will be used to read the contents of the
1280  // source manager block initially, and then lazily read
1281  // source-location entries as needed.
1282  SLocEntryCursor = F.Stream;
1283 
1284  // The stream itself is going to skip over the source manager block.
1285  if (F.Stream.SkipBlock()) {
1286  Error("malformed block record in AST file");
1287  return true;
1288  }
1289 
1290  // Enter the source manager block.
1291  if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1292  Error("malformed source manager block record in AST file");
1293  return true;
1294  }
1295 
1296  RecordData Record;
1297  while (true) {
1298  llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1299 
1300  switch (E.Kind) {
1301  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1303  Error("malformed block record in AST file");
1304  return true;
1305  case llvm::BitstreamEntry::EndBlock:
1306  return false;
1307  case llvm::BitstreamEntry::Record:
1308  // The interesting case.
1309  break;
1310  }
1311 
1312  // Read a record.
1313  Record.clear();
1314  StringRef Blob;
1315  switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1316  default: // Default behavior: ignore.
1317  break;
1318 
1319  case SM_SLOC_FILE_ENTRY:
1320  case SM_SLOC_BUFFER_ENTRY:
1322  // Once we hit one of the source location entries, we're done.
1323  return false;
1324  }
1325  }
1326 }
1327 
1328 /// If a header file is not found at the path that we expect it to be
1329 /// and the PCH file was moved from its original location, try to resolve the
1330 /// file by assuming that header+PCH were moved together and the header is in
1331 /// the same place relative to the PCH.
1332 static std::string
1334  const std::string &OriginalDir,
1335  const std::string &CurrDir) {
1336  assert(OriginalDir != CurrDir &&
1337  "No point trying to resolve the file if the PCH dir didn't change");
1338 
1339  using namespace llvm::sys;
1340 
1341  SmallString<128> filePath(Filename);
1342  fs::make_absolute(filePath);
1343  assert(path::is_absolute(OriginalDir));
1344  SmallString<128> currPCHPath(CurrDir);
1345 
1346  path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1347  fileDirE = path::end(path::parent_path(filePath));
1348  path::const_iterator origDirI = path::begin(OriginalDir),
1349  origDirE = path::end(OriginalDir);
1350  // Skip the common path components from filePath and OriginalDir.
1351  while (fileDirI != fileDirE && origDirI != origDirE &&
1352  *fileDirI == *origDirI) {
1353  ++fileDirI;
1354  ++origDirI;
1355  }
1356  for (; origDirI != origDirE; ++origDirI)
1357  path::append(currPCHPath, "..");
1358  path::append(currPCHPath, fileDirI, fileDirE);
1359  path::append(currPCHPath, path::filename(Filename));
1360  return currPCHPath.str();
1361 }
1362 
1364  if (ID == 0)
1365  return false;
1366 
1367  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1368  Error("source location entry ID out-of-range for AST file");
1369  return true;
1370  }
1371 
1372  // Local helper to read the (possibly-compressed) buffer data following the
1373  // entry record.
1374  auto ReadBuffer = [this](
1375  BitstreamCursor &SLocEntryCursor,
1376  StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1377  RecordData Record;
1378  StringRef Blob;
1379  unsigned Code = SLocEntryCursor.ReadCode();
1380  unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1381 
1382  if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1383  if (!llvm::zlib::isAvailable()) {
1384  Error("zlib is not available");
1385  return nullptr;
1386  }
1387  SmallString<0> Uncompressed;
1388  if (llvm::Error E =
1389  llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1390  Error("could not decompress embedded file contents: " +
1391  llvm::toString(std::move(E)));
1392  return nullptr;
1393  }
1394  return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1395  } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1396  return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1397  } else {
1398  Error("AST record has invalid code");
1399  return nullptr;
1400  }
1401  };
1402 
1403  ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1404  F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1405  BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1406  unsigned BaseOffset = F->SLocEntryBaseOffset;
1407 
1408  ++NumSLocEntriesRead;
1409  llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1410  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1411  Error("incorrectly-formatted source location entry in AST file");
1412  return true;
1413  }
1414 
1415  RecordData Record;
1416  StringRef Blob;
1417  switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1418  default:
1419  Error("incorrectly-formatted source location entry in AST file");
1420  return true;
1421 
1422  case SM_SLOC_FILE_ENTRY: {
1423  // We will detect whether a file changed and return 'Failure' for it, but
1424  // we will also try to fail gracefully by setting up the SLocEntry.
1425  unsigned InputID = Record[4];
1426  InputFile IF = getInputFile(*F, InputID);
1427  const FileEntry *File = IF.getFile();
1428  bool OverriddenBuffer = IF.isOverridden();
1429 
1430  // Note that we only check if a File was returned. If it was out-of-date
1431  // we have complained but we will continue creating a FileID to recover
1432  // gracefully.
1433  if (!File)
1434  return true;
1435 
1436  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1437  if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1438  // This is the module's main file.
1439  IncludeLoc = getImportLocation(F);
1440  }
1442  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1443  FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1444  ID, BaseOffset + Record[0]);
1445  SrcMgr::FileInfo &FileInfo =
1446  const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1447  FileInfo.NumCreatedFIDs = Record[5];
1448  if (Record[3])
1449  FileInfo.setHasLineDirectives();
1450 
1451  const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1452  unsigned NumFileDecls = Record[7];
1453  if (NumFileDecls && ContextObj) {
1454  assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1455  FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1456  NumFileDecls));
1457  }
1458 
1459  const SrcMgr::ContentCache *ContentCache
1460  = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1461  if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1462  ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1463  !ContentCache->getRawBuffer()) {
1464  auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1465  if (!Buffer)
1466  return true;
1467  SourceMgr.overrideFileContents(File, std::move(Buffer));
1468  }
1469 
1470  break;
1471  }
1472 
1473  case SM_SLOC_BUFFER_ENTRY: {
1474  const char *Name = Blob.data();
1475  unsigned Offset = Record[0];
1477  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1478  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1479  if (IncludeLoc.isInvalid() && F->isModule()) {
1480  IncludeLoc = getImportLocation(F);
1481  }
1482 
1483  auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1484  if (!Buffer)
1485  return true;
1486  SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1487  BaseOffset + Offset, IncludeLoc);
1488  break;
1489  }
1490 
1491  case SM_SLOC_EXPANSION_ENTRY: {
1492  SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1493  SourceMgr.createExpansionLoc(SpellingLoc,
1494  ReadSourceLocation(*F, Record[2]),
1495  ReadSourceLocation(*F, Record[3]),
1496  Record[5],
1497  Record[4],
1498  ID,
1499  BaseOffset + Record[0]);
1500  break;
1501  }
1502  }
1503 
1504  return false;
1505 }
1506 
1507 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1508  if (ID == 0)
1509  return std::make_pair(SourceLocation(), "");
1510 
1511  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1512  Error("source location entry ID out-of-range for AST file");
1513  return std::make_pair(SourceLocation(), "");
1514  }
1515 
1516  // Find which module file this entry lands in.
1517  ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1518  if (!M->isModule())
1519  return std::make_pair(SourceLocation(), "");
1520 
1521  // FIXME: Can we map this down to a particular submodule? That would be
1522  // ideal.
1523  return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1524 }
1525 
1526 /// Find the location where the module F is imported.
1527 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1528  if (F->ImportLoc.isValid())
1529  return F->ImportLoc;
1530 
1531  // Otherwise we have a PCH. It's considered to be "imported" at the first
1532  // location of its includer.
1533  if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1534  // Main file is the importer.
1535  assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1536  return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1537  }
1538  return F->ImportedBy[0]->FirstLoc;
1539 }
1540 
1541 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1542 /// specified cursor. Read the abbreviations that are at the top of the block
1543 /// and then leave the cursor pointing into the block.
1544 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1545  if (Cursor.EnterSubBlock(BlockID))
1546  return true;
1547 
1548  while (true) {
1549  uint64_t Offset = Cursor.GetCurrentBitNo();
1550  unsigned Code = Cursor.ReadCode();
1551 
1552  // We expect all abbrevs to be at the start of the block.
1553  if (Code != llvm::bitc::DEFINE_ABBREV) {
1554  Cursor.JumpToBit(Offset);
1555  return false;
1556  }
1557  Cursor.ReadAbbrevRecord();
1558  }
1559 }
1560 
1562  unsigned &Idx) {
1563  Token Tok;
1564  Tok.startToken();
1565  Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1566  Tok.setLength(Record[Idx++]);
1567  if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1568  Tok.setIdentifierInfo(II);
1569  Tok.setKind((tok::TokenKind)Record[Idx++]);
1570  Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1571  return Tok;
1572 }
1573 
1575  BitstreamCursor &Stream = F.MacroCursor;
1576 
1577  // Keep track of where we are in the stream, then jump back there
1578  // after reading this macro.
1579  SavedStreamPosition SavedPosition(Stream);
1580 
1581  Stream.JumpToBit(Offset);
1582  RecordData Record;
1584  MacroInfo *Macro = nullptr;
1585 
1586  while (true) {
1587  // Advance to the next record, but if we get to the end of the block, don't
1588  // pop it (removing all the abbreviations from the cursor) since we want to
1589  // be able to reseek within the block and read entries.
1590  unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1591  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1592 
1593  switch (Entry.Kind) {
1594  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1596  Error("malformed block record in AST file");
1597  return Macro;
1598  case llvm::BitstreamEntry::EndBlock:
1599  return Macro;
1600  case llvm::BitstreamEntry::Record:
1601  // The interesting case.
1602  break;
1603  }
1604 
1605  // Read a record.
1606  Record.clear();
1607  PreprocessorRecordTypes RecType =
1608  (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1609  switch (RecType) {
1610  case PP_MODULE_MACRO:
1612  return Macro;
1613 
1614  case PP_MACRO_OBJECT_LIKE:
1615  case PP_MACRO_FUNCTION_LIKE: {
1616  // If we already have a macro, that means that we've hit the end
1617  // of the definition of the macro we were looking for. We're
1618  // done.
1619  if (Macro)
1620  return Macro;
1621 
1622  unsigned NextIndex = 1; // Skip identifier ID.
1623  SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1624  MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1625  MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1626  MI->setIsUsed(Record[NextIndex++]);
1627  MI->setUsedForHeaderGuard(Record[NextIndex++]);
1628 
1629  if (RecType == PP_MACRO_FUNCTION_LIKE) {
1630  // Decode function-like macro info.
1631  bool isC99VarArgs = Record[NextIndex++];
1632  bool isGNUVarArgs = Record[NextIndex++];
1633  bool hasCommaPasting = Record[NextIndex++];
1634  MacroParams.clear();
1635  unsigned NumArgs = Record[NextIndex++];
1636  for (unsigned i = 0; i != NumArgs; ++i)
1637  MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1638 
1639  // Install function-like macro info.
1640  MI->setIsFunctionLike();
1641  if (isC99VarArgs) MI->setIsC99Varargs();
1642  if (isGNUVarArgs) MI->setIsGNUVarargs();
1643  if (hasCommaPasting) MI->setHasCommaPasting();
1644  MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1645  }
1646 
1647  // Remember that we saw this macro last so that we add the tokens that
1648  // form its body to it.
1649  Macro = MI;
1650 
1651  if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1652  Record[NextIndex]) {
1653  // We have a macro definition. Register the association
1655  GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1656  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1657  PreprocessingRecord::PPEntityID PPID =
1658  PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1659  MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1660  PPRec.getPreprocessedEntity(PPID));
1661  if (PPDef)
1662  PPRec.RegisterMacroDefinition(Macro, PPDef);
1663  }
1664 
1665  ++NumMacrosRead;
1666  break;
1667  }
1668 
1669  case PP_TOKEN: {
1670  // If we see a TOKEN before a PP_MACRO_*, then the file is
1671  // erroneous, just pretend we didn't see this.
1672  if (!Macro) break;
1673 
1674  unsigned Idx = 0;
1675  Token Tok = ReadToken(F, Record, Idx);
1676  Macro->AddTokenToBody(Tok);
1677  break;
1678  }
1679  }
1680  }
1681 }
1682 
1685  unsigned LocalID) const {
1686  if (!M.ModuleOffsetMap.empty())
1687  ReadModuleOffsetMap(M);
1688 
1691  assert(I != M.PreprocessedEntityRemap.end()
1692  && "Invalid index into preprocessed entity index remap");
1693 
1694  return LocalID + I->second;
1695 }
1696 
1698  return llvm::hash_combine(ikey.Size, ikey.ModTime);
1699 }
1700 
1702 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1703  internal_key_type ikey = {FE->getSize(),
1704  M.HasTimestamps ? FE->getModificationTime() : 0,
1705  FE->getName(), /*Imported*/ false};
1706  return ikey;
1707 }
1708 
1709 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1710  if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1711  return false;
1712 
1713  if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1714  return true;
1715 
1716  // Determine whether the actual files are equivalent.
1717  FileManager &FileMgr = Reader.getFileManager();
1718  auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1719  if (!Key.Imported)
1720  return FileMgr.getFile(Key.Filename);
1721 
1722  std::string Resolved = Key.Filename;
1723  Reader.ResolveImportedPath(M, Resolved);
1724  return FileMgr.getFile(Resolved);
1725  };
1726 
1727  const FileEntry *FEA = GetFile(a);
1728  const FileEntry *FEB = GetFile(b);
1729  return FEA && FEA == FEB;
1730 }
1731 
1732 std::pair<unsigned, unsigned>
1733 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1734  using namespace llvm::support;
1735 
1736  unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1737  unsigned DataLen = (unsigned) *d++;
1738  return std::make_pair(KeyLen, DataLen);
1739 }
1740 
1742 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1743  using namespace llvm::support;
1744 
1745  internal_key_type ikey;
1746  ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1747  ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1748  ikey.Filename = (const char *)d;
1749  ikey.Imported = true;
1750  return ikey;
1751 }
1752 
1754 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1755  unsigned DataLen) {
1756  using namespace llvm::support;
1757 
1758  const unsigned char *End = d + DataLen;
1759  HeaderFileInfo HFI;
1760  unsigned Flags = *d++;
1761  // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1762  HFI.isImport |= (Flags >> 5) & 0x01;
1763  HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1764  HFI.DirInfo = (Flags >> 1) & 0x07;
1765  HFI.IndexHeaderMapHeader = Flags & 0x01;
1766  // FIXME: Find a better way to handle this. Maybe just store a
1767  // "has been included" flag?
1768  HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1769  HFI.NumIncludes);
1770  HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1771  M, endian::readNext<uint32_t, little, unaligned>(d));
1772  if (unsigned FrameworkOffset =
1773  endian::readNext<uint32_t, little, unaligned>(d)) {
1774  // The framework offset is 1 greater than the actual offset,
1775  // since 0 is used as an indicator for "no framework name".
1776  StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1777  HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1778  }
1779 
1780  assert((End - d) % 4 == 0 &&
1781  "Wrong data length in HeaderFileInfo deserialization");
1782  while (d != End) {
1783  uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1784  auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1785  LocalSMID >>= 2;
1786 
1787  // This header is part of a module. Associate it with the module to enable
1788  // implicit module import.
1789  SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1790  Module *Mod = Reader.getSubmodule(GlobalSMID);
1791  FileManager &FileMgr = Reader.getFileManager();
1792  ModuleMap &ModMap =
1793  Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1794 
1795  std::string Filename = key.Filename;
1796  if (key.Imported)
1797  Reader.ResolveImportedPath(M, Filename);
1798  // FIXME: This is not always the right filename-as-written, but we're not
1799  // going to use this information to rebuild the module, so it doesn't make
1800  // a lot of difference.
1801  Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1802  ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1803  HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1804  }
1805 
1806  // This HeaderFileInfo was externally loaded.
1807  HFI.External = true;
1808  HFI.IsValid = true;
1809  return HFI;
1810 }
1811 
1813  ModuleFile *M,
1814  uint64_t MacroDirectivesOffset) {
1815  assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1816  PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1817 }
1818 
1820  // Note that we are loading defined macros.
1821  Deserializing Macros(this);
1822 
1823  for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1824  BitstreamCursor &MacroCursor = I.MacroCursor;
1825 
1826  // If there was no preprocessor block, skip this file.
1827  if (MacroCursor.getBitcodeBytes().empty())
1828  continue;
1829 
1830  BitstreamCursor Cursor = MacroCursor;
1831  Cursor.JumpToBit(I.MacroStartOffset);
1832 
1833  RecordData Record;
1834  while (true) {
1835  llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1836 
1837  switch (E.Kind) {
1838  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1840  Error("malformed block record in AST file");
1841  return;
1842  case llvm::BitstreamEntry::EndBlock:
1843  goto NextCursor;
1844 
1845  case llvm::BitstreamEntry::Record:
1846  Record.clear();
1847  switch (Cursor.readRecord(E.ID, Record)) {
1848  default: // Default behavior: ignore.
1849  break;
1850 
1851  case PP_MACRO_OBJECT_LIKE:
1852  case PP_MACRO_FUNCTION_LIKE: {
1853  IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1854  if (II->isOutOfDate())
1855  updateOutOfDateIdentifier(*II);
1856  break;
1857  }
1858 
1859  case PP_TOKEN:
1860  // Ignore tokens.
1861  break;
1862  }
1863  break;
1864  }
1865  }
1866  NextCursor: ;
1867  }
1868 }
1869 
1870 namespace {
1871 
1872  /// Visitor class used to look up identifirs in an AST file.
1873  class IdentifierLookupVisitor {
1874  StringRef Name;
1875  unsigned NameHash;
1876  unsigned PriorGeneration;
1877  unsigned &NumIdentifierLookups;
1878  unsigned &NumIdentifierLookupHits;
1879  IdentifierInfo *Found = nullptr;
1880 
1881  public:
1882  IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1883  unsigned &NumIdentifierLookups,
1884  unsigned &NumIdentifierLookupHits)
1885  : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1886  PriorGeneration(PriorGeneration),
1887  NumIdentifierLookups(NumIdentifierLookups),
1888  NumIdentifierLookupHits(NumIdentifierLookupHits) {}
1889 
1890  bool operator()(ModuleFile &M) {
1891  // If we've already searched this module file, skip it now.
1892  if (M.Generation <= PriorGeneration)
1893  return true;
1894 
1895  ASTIdentifierLookupTable *IdTable
1897  if (!IdTable)
1898  return false;
1899 
1900  ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1901  Found);
1902  ++NumIdentifierLookups;
1903  ASTIdentifierLookupTable::iterator Pos =
1904  IdTable->find_hashed(Name, NameHash, &Trait);
1905  if (Pos == IdTable->end())
1906  return false;
1907 
1908  // Dereferencing the iterator has the effect of building the
1909  // IdentifierInfo node and populating it with the various
1910  // declarations it needs.
1911  ++NumIdentifierLookupHits;
1912  Found = *Pos;
1913  return true;
1914  }
1915 
1916  // Retrieve the identifier info found within the module
1917  // files.
1918  IdentifierInfo *getIdentifierInfo() const { return Found; }
1919  };
1920 
1921 } // namespace
1922 
1924  // Note that we are loading an identifier.
1925  Deserializing AnIdentifier(this);
1926 
1927  unsigned PriorGeneration = 0;
1928  if (getContext().getLangOpts().Modules)
1929  PriorGeneration = IdentifierGeneration[&II];
1930 
1931  // If there is a global index, look there first to determine which modules
1932  // provably do not have any results for this identifier.
1934  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1935  if (!loadGlobalIndex()) {
1936  if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1937  HitsPtr = &Hits;
1938  }
1939  }
1940 
1941  IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1942  NumIdentifierLookups,
1943  NumIdentifierLookupHits);
1944  ModuleMgr.visit(Visitor, HitsPtr);
1945  markIdentifierUpToDate(&II);
1946 }
1947 
1949  if (!II)
1950  return;
1951 
1952  II->setOutOfDate(false);
1953 
1954  // Update the generation for this identifier.
1955  if (getContext().getLangOpts().Modules)
1956  IdentifierGeneration[II] = getGeneration();
1957 }
1958 
1960  const PendingMacroInfo &PMInfo) {
1961  ModuleFile &M = *PMInfo.M;
1962 
1963  BitstreamCursor &Cursor = M.MacroCursor;
1964  SavedStreamPosition SavedPosition(Cursor);
1965  Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1966 
1967  struct ModuleMacroRecord {
1968  SubmoduleID SubModID;
1969  MacroInfo *MI;
1970  SmallVector<SubmoduleID, 8> Overrides;
1971  };
1973 
1974  // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1975  // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1976  // macro histroy.
1977  RecordData Record;
1978  while (true) {
1979  llvm::BitstreamEntry Entry =
1980  Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1981  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1982  Error("malformed block record in AST file");
1983  return;
1984  }
1985 
1986  Record.clear();
1987  switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1989  break;
1990 
1991  case PP_MODULE_MACRO: {
1992  ModuleMacros.push_back(ModuleMacroRecord());
1993  auto &Info = ModuleMacros.back();
1994  Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1995  Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1996  for (int I = 2, N = Record.size(); I != N; ++I)
1997  Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1998  continue;
1999  }
2000 
2001  default:
2002  Error("malformed block record in AST file");
2003  return;
2004  }
2005 
2006  // We found the macro directive history; that's the last record
2007  // for this macro.
2008  break;
2009  }
2010 
2011  // Module macros are listed in reverse dependency order.
2012  {
2013  std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2015  for (auto &MMR : ModuleMacros) {
2016  Overrides.clear();
2017  for (unsigned ModID : MMR.Overrides) {
2018  Module *Mod = getSubmodule(ModID);
2019  auto *Macro = PP.getModuleMacro(Mod, II);
2020  assert(Macro && "missing definition for overridden macro");
2021  Overrides.push_back(Macro);
2022  }
2023 
2024  bool Inserted = false;
2025  Module *Owner = getSubmodule(MMR.SubModID);
2026  PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2027  }
2028  }
2029 
2030  // Don't read the directive history for a module; we don't have anywhere
2031  // to put it.
2032  if (M.isModule())
2033  return;
2034 
2035  // Deserialize the macro directives history in reverse source-order.
2036  MacroDirective *Latest = nullptr, *Earliest = nullptr;
2037  unsigned Idx = 0, N = Record.size();
2038  while (Idx < N) {
2039  MacroDirective *MD = nullptr;
2040  SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2041  MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2042  switch (K) {
2044  MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2045  MD = PP.AllocateDefMacroDirective(MI, Loc);
2046  break;
2047  }
2049  MD = PP.AllocateUndefMacroDirective(Loc);
2050  break;
2052  bool isPublic = Record[Idx++];
2053  MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2054  break;
2055  }
2056 
2057  if (!Latest)
2058  Latest = MD;
2059  if (Earliest)
2060  Earliest->setPrevious(MD);
2061  Earliest = MD;
2062  }
2063 
2064  if (Latest)
2065  PP.setLoadedMacroDirective(II, Earliest, Latest);
2066 }
2067 
2068 ASTReader::InputFileInfo
2069 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2070  // Go find this input file.
2071  BitstreamCursor &Cursor = F.InputFilesCursor;
2072  SavedStreamPosition SavedPosition(Cursor);
2073  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2074 
2075  unsigned Code = Cursor.ReadCode();
2076  RecordData Record;
2077  StringRef Blob;
2078 
2079  unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2080  assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2081  "invalid record type for input file");
2082  (void)Result;
2083 
2084  assert(Record[0] == ID && "Bogus stored ID or offset");
2085  InputFileInfo R;
2086  R.StoredSize = static_cast<off_t>(Record[1]);
2087  R.StoredTime = static_cast<time_t>(Record[2]);
2088  R.Overridden = static_cast<bool>(Record[3]);
2089  R.Transient = static_cast<bool>(Record[4]);
2090  R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2091  R.Filename = Blob;
2092  ResolveImportedPath(F, R.Filename);
2093  return R;
2094 }
2095 
2096 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2097 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2098  // If this ID is bogus, just return an empty input file.
2099  if (ID == 0 || ID > F.InputFilesLoaded.size())
2100  return InputFile();
2101 
2102  // If we've already loaded this input file, return it.
2103  if (F.InputFilesLoaded[ID-1].getFile())
2104  return F.InputFilesLoaded[ID-1];
2105 
2106  if (F.InputFilesLoaded[ID-1].isNotFound())
2107  return InputFile();
2108 
2109  // Go find this input file.
2110  BitstreamCursor &Cursor = F.InputFilesCursor;
2111  SavedStreamPosition SavedPosition(Cursor);
2112  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2113 
2114  InputFileInfo FI = readInputFileInfo(F, ID);
2115  off_t StoredSize = FI.StoredSize;
2116  time_t StoredTime = FI.StoredTime;
2117  bool Overridden = FI.Overridden;
2118  bool Transient = FI.Transient;
2119  StringRef Filename = FI.Filename;
2120 
2121  const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2122  // If we didn't find the file, resolve it relative to the
2123  // original directory from which this AST file was created.
2124  if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2125  F.OriginalDir != F.BaseDirectory) {
2126  std::string Resolved = resolveFileRelativeToOriginalDir(
2127  Filename, F.OriginalDir, F.BaseDirectory);
2128  if (!Resolved.empty())
2129  File = FileMgr.getFile(Resolved);
2130  }
2131 
2132  // For an overridden file, create a virtual file with the stored
2133  // size/timestamp.
2134  if ((Overridden || Transient) && File == nullptr)
2135  File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2136 
2137  if (File == nullptr) {
2138  if (Complain) {
2139  std::string ErrorStr = "could not find file '";
2140  ErrorStr += Filename;
2141  ErrorStr += "' referenced by AST file '";
2142  ErrorStr += F.FileName;
2143  ErrorStr += "'";
2144  Error(ErrorStr);
2145  }
2146  // Record that we didn't find the file.
2148  return InputFile();
2149  }
2150 
2151  // Check if there was a request to override the contents of the file
2152  // that was part of the precompiled header. Overriding such a file
2153  // can lead to problems when lexing using the source locations from the
2154  // PCH.
2155  SourceManager &SM = getSourceManager();
2156  // FIXME: Reject if the overrides are different.
2157  if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2158  if (Complain)
2159  Error(diag::err_fe_pch_file_overridden, Filename);
2160  // After emitting the diagnostic, recover by disabling the override so
2161  // that the original file will be used.
2162  //
2163  // FIXME: This recovery is just as broken as the original state; there may
2164  // be another precompiled module that's using the overridden contents, or
2165  // we might be half way through parsing it. Instead, we should treat the
2166  // overridden contents as belonging to a separate FileEntry.
2167  SM.disableFileContentsOverride(File);
2168  // The FileEntry is a virtual file entry with the size of the contents
2169  // that would override the original contents. Set it to the original's
2170  // size/time.
2171  FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2172  StoredSize, StoredTime);
2173  }
2174 
2175  bool IsOutOfDate = false;
2176 
2177  // For an overridden file, there is nothing to validate.
2178  if (!Overridden && //
2179  (StoredSize != File->getSize() ||
2180  (StoredTime && StoredTime != File->getModificationTime() &&
2181  !DisableValidation)
2182  )) {
2183  if (Complain) {
2184  // Build a list of the PCH imports that got us here (in reverse).
2185  SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2186  while (!ImportStack.back()->ImportedBy.empty())
2187  ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2188 
2189  // The top-level PCH is stale.
2190  StringRef TopLevelPCHName(ImportStack.back()->FileName);
2191  unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2192  if (DiagnosticKind == 0)
2193  Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2194  else if (DiagnosticKind == 1)
2195  Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2196  else
2197  Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2198 
2199  // Print the import stack.
2200  if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2201  Diag(diag::note_pch_required_by)
2202  << Filename << ImportStack[0]->FileName;
2203  for (unsigned I = 1; I < ImportStack.size(); ++I)
2204  Diag(diag::note_pch_required_by)
2205  << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2206  }
2207 
2208  if (!Diags.isDiagnosticInFlight())
2209  Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2210  }
2211 
2212  IsOutOfDate = true;
2213  }
2214  // FIXME: If the file is overridden and we've already opened it,
2215  // issue an error (or split it into a separate FileEntry).
2216 
2217  InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2218 
2219  // Note that we've loaded this input file.
2220  F.InputFilesLoaded[ID-1] = IF;
2221  return IF;
2222 }
2223 
2224 /// If we are loading a relocatable PCH or module file, and the filename
2225 /// is not an absolute path, add the system or module root to the beginning of
2226 /// the file name.
2228  // Resolve relative to the base directory, if we have one.
2229  if (!M.BaseDirectory.empty())
2230  return ResolveImportedPath(Filename, M.BaseDirectory);
2231 }
2232 
2233 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2234  if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2235  return;
2236 
2237  SmallString<128> Buffer;
2238  llvm::sys::path::append(Buffer, Prefix, Filename);
2239  Filename.assign(Buffer.begin(), Buffer.end());
2240 }
2241 
2242 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2243  switch (ARR) {
2244  case ASTReader::Failure: return true;
2245  case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2246  case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2249  return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2250  case ASTReader::HadErrors: return true;
2251  case ASTReader::Success: return false;
2252  }
2253 
2254  llvm_unreachable("unknown ASTReadResult");
2255 }
2256 
2257 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2258  BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2259  bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2260  std::string &SuggestedPredefines) {
2261  if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2262  return Failure;
2263 
2264  // Read all of the records in the options block.
2265  RecordData Record;
2266  ASTReadResult Result = Success;
2267  while (true) {
2268  llvm::BitstreamEntry Entry = Stream.advance();
2269 
2270  switch (Entry.Kind) {
2272  case llvm::BitstreamEntry::SubBlock:
2273  return Failure;
2274 
2275  case llvm::BitstreamEntry::EndBlock:
2276  return Result;
2277 
2278  case llvm::BitstreamEntry::Record:
2279  // The interesting case.
2280  break;
2281  }
2282 
2283  // Read and process a record.
2284  Record.clear();
2285  switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2286  case LANGUAGE_OPTIONS: {
2287  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2288  if (ParseLanguageOptions(Record, Complain, Listener,
2289  AllowCompatibleConfigurationMismatch))
2290  Result = ConfigurationMismatch;
2291  break;
2292  }
2293 
2294  case TARGET_OPTIONS: {
2295  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2296  if (ParseTargetOptions(Record, Complain, Listener,
2297  AllowCompatibleConfigurationMismatch))
2298  Result = ConfigurationMismatch;
2299  break;
2300  }
2301 
2302  case FILE_SYSTEM_OPTIONS: {
2303  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2304  if (!AllowCompatibleConfigurationMismatch &&
2305  ParseFileSystemOptions(Record, Complain, Listener))
2306  Result = ConfigurationMismatch;
2307  break;
2308  }
2309 
2310  case HEADER_SEARCH_OPTIONS: {
2311  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2312  if (!AllowCompatibleConfigurationMismatch &&
2313  ParseHeaderSearchOptions(Record, Complain, Listener))
2314  Result = ConfigurationMismatch;
2315  break;
2316  }
2317 
2318  case PREPROCESSOR_OPTIONS:
2319  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2320  if (!AllowCompatibleConfigurationMismatch &&
2321  ParsePreprocessorOptions(Record, Complain, Listener,
2322  SuggestedPredefines))
2323  Result = ConfigurationMismatch;
2324  break;
2325  }
2326  }
2327 }
2328 
2330 ASTReader::ReadControlBlock(ModuleFile &F,
2332  const ModuleFile *ImportedBy,
2333  unsigned ClientLoadCapabilities) {
2334  BitstreamCursor &Stream = F.Stream;
2335  ASTReadResult Result = Success;
2336 
2337  if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2338  Error("malformed block record in AST file");
2339  return Failure;
2340  }
2341 
2342  // Lambda to read the unhashed control block the first time it's called.
2343  //
2344  // For PCM files, the unhashed control block cannot be read until after the
2345  // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2346  // need to look ahead before reading the IMPORTS record. For consistency,
2347  // this block is always read somehow (see BitstreamEntry::EndBlock).
2348  bool HasReadUnhashedControlBlock = false;
2349  auto readUnhashedControlBlockOnce = [&]() {
2350  if (!HasReadUnhashedControlBlock) {
2351  HasReadUnhashedControlBlock = true;
2352  if (ASTReadResult Result =
2353  readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2354  return Result;
2355  }
2356  return Success;
2357  };
2358 
2359  // Read all of the records and blocks in the control block.
2360  RecordData Record;
2361  unsigned NumInputs = 0;
2362  unsigned NumUserInputs = 0;
2363  while (true) {
2364  llvm::BitstreamEntry Entry = Stream.advance();
2365 
2366  switch (Entry.Kind) {
2368  Error("malformed block record in AST file");
2369  return Failure;
2370  case llvm::BitstreamEntry::EndBlock: {
2371  // Validate the module before returning. This call catches an AST with
2372  // no module name and no imports.
2373  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2374  return Result;
2375 
2376  // Validate input files.
2377  const HeaderSearchOptions &HSOpts =
2378  PP.getHeaderSearchInfo().getHeaderSearchOpts();
2379 
2380  // All user input files reside at the index range [0, NumUserInputs), and
2381  // system input files reside at [NumUserInputs, NumInputs). For explicitly
2382  // loaded module files, ignore missing inputs.
2383  if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2384  F.Kind != MK_PrebuiltModule) {
2385  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2386 
2387  // If we are reading a module, we will create a verification timestamp,
2388  // so we verify all input files. Otherwise, verify only user input
2389  // files.
2390 
2391  unsigned N = NumUserInputs;
2392  if (ValidateSystemInputs ||
2395  F.Kind == MK_ImplicitModule))
2396  N = NumInputs;
2397 
2398  for (unsigned I = 0; I < N; ++I) {
2399  InputFile IF = getInputFile(F, I+1, Complain);
2400  if (!IF.getFile() || IF.isOutOfDate())
2401  return OutOfDate;
2402  }
2403  }
2404 
2405  if (Listener)
2406  Listener->visitModuleFile(F.FileName, F.Kind);
2407 
2408  if (Listener && Listener->needsInputFileVisitation()) {
2409  unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2410  : NumUserInputs;
2411  for (unsigned I = 0; I < N; ++I) {
2412  bool IsSystem = I >= NumUserInputs;
2413  InputFileInfo FI = readInputFileInfo(F, I+1);
2414  Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2415  F.Kind == MK_ExplicitModule ||
2416  F.Kind == MK_PrebuiltModule);
2417  }
2418  }
2419 
2420  return Result;
2421  }
2422 
2423  case llvm::BitstreamEntry::SubBlock:
2424  switch (Entry.ID) {
2425  case INPUT_FILES_BLOCK_ID:
2426  F.InputFilesCursor = Stream;
2427  if (Stream.SkipBlock() || // Skip with the main cursor
2428  // Read the abbreviations
2429  ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2430  Error("malformed block record in AST file");
2431  return Failure;
2432  }
2433  continue;
2434 
2435  case OPTIONS_BLOCK_ID:
2436  // If we're reading the first module for this group, check its options
2437  // are compatible with ours. For modules it imports, no further checking
2438  // is required, because we checked them when we built it.
2439  if (Listener && !ImportedBy) {
2440  // Should we allow the configuration of the module file to differ from
2441  // the configuration of the current translation unit in a compatible
2442  // way?
2443  //
2444  // FIXME: Allow this for files explicitly specified with -include-pch.
2445  bool AllowCompatibleConfigurationMismatch =
2447 
2448  Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2449  AllowCompatibleConfigurationMismatch,
2450  *Listener, SuggestedPredefines);
2451  if (Result == Failure) {
2452  Error("malformed block record in AST file");
2453  return Result;
2454  }
2455 
2456  if (DisableValidation ||
2457  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2458  Result = Success;
2459 
2460  // If we can't load the module, exit early since we likely
2461  // will rebuild the module anyway. The stream may be in the
2462  // middle of a block.
2463  if (Result != Success)
2464  return Result;
2465  } else if (Stream.SkipBlock()) {
2466  Error("malformed block record in AST file");
2467  return Failure;
2468  }
2469  continue;
2470 
2471  default:
2472  if (Stream.SkipBlock()) {
2473  Error("malformed block record in AST file");
2474  return Failure;
2475  }
2476  continue;
2477  }
2478 
2479  case llvm::BitstreamEntry::Record:
2480  // The interesting case.
2481  break;
2482  }
2483 
2484  // Read and process a record.
2485  Record.clear();
2486  StringRef Blob;
2487  switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2488  case METADATA: {
2489  if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2490  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2491  Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2492  : diag::err_pch_version_too_new);
2493  return VersionMismatch;
2494  }
2495 
2496  bool hasErrors = Record[7];
2497  if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2498  Diag(diag::err_pch_with_compiler_errors);
2499  return HadErrors;
2500  }
2501  if (hasErrors) {
2502  Diags.ErrorOccurred = true;
2503  Diags.UncompilableErrorOccurred = true;
2504  Diags.UnrecoverableErrorOccurred = true;
2505  }
2506 
2507  F.RelocatablePCH = Record[4];
2508  // Relative paths in a relocatable PCH are relative to our sysroot.
2509  if (F.RelocatablePCH)
2510  F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2511 
2512  F.HasTimestamps = Record[5];
2513 
2514  F.PCHHasObjectFile = Record[6];
2515 
2516  const std::string &CurBranch = getClangFullRepositoryVersion();
2517  StringRef ASTBranch = Blob;
2518  if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2519  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2520  Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2521  return VersionMismatch;
2522  }
2523  break;
2524  }
2525 
2526  case IMPORTS: {
2527  // Validate the AST before processing any imports (otherwise, untangling
2528  // them can be error-prone and expensive). A module will have a name and
2529  // will already have been validated, but this catches the PCH case.
2530  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2531  return Result;
2532 
2533  // Load each of the imported PCH files.
2534  unsigned Idx = 0, N = Record.size();
2535  while (Idx < N) {
2536  // Read information about the AST file.
2537  ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2538  // The import location will be the local one for now; we will adjust
2539  // all import locations of module imports after the global source
2540  // location info are setup, in ReadAST.
2541  SourceLocation ImportLoc =
2542  ReadUntranslatedSourceLocation(Record[Idx++]);
2543  off_t StoredSize = (off_t)Record[Idx++];
2544  time_t StoredModTime = (time_t)Record[Idx++];
2545  ASTFileSignature StoredSignature = {
2546  {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2547  (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2548  (uint32_t)Record[Idx++]}}};
2549 
2550  std::string ImportedName = ReadString(Record, Idx);
2551  std::string ImportedFile;
2552 
2553  // For prebuilt and explicit modules first consult the file map for
2554  // an override. Note that here we don't search prebuilt module
2555  // directories, only the explicit name to file mappings. Also, we will
2556  // still verify the size/signature making sure it is essentially the
2557  // same file but perhaps in a different location.
2558  if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2559  ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2560  ImportedName, /*FileMapOnly*/ true);
2561 
2562  if (ImportedFile.empty())
2563  ImportedFile = ReadPath(F, Record, Idx);
2564  else
2565  SkipPath(Record, Idx);
2566 
2567  // If our client can't cope with us being out of date, we can't cope with
2568  // our dependency being missing.
2569  unsigned Capabilities = ClientLoadCapabilities;
2570  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2571  Capabilities &= ~ARR_Missing;
2572 
2573  // Load the AST file.
2574  auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2575  Loaded, StoredSize, StoredModTime,
2576  StoredSignature, Capabilities);
2577 
2578  // If we diagnosed a problem, produce a backtrace.
2579  if (isDiagnosedResult(Result, Capabilities))
2580  Diag(diag::note_module_file_imported_by)
2581  << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2582 
2583  switch (Result) {
2584  case Failure: return Failure;
2585  // If we have to ignore the dependency, we'll have to ignore this too.
2586  case Missing:
2587  case OutOfDate: return OutOfDate;
2588  case VersionMismatch: return VersionMismatch;
2589  case ConfigurationMismatch: return ConfigurationMismatch;
2590  case HadErrors: return HadErrors;
2591  case Success: break;
2592  }
2593  }
2594  break;
2595  }
2596 
2597  case ORIGINAL_FILE:
2598  F.OriginalSourceFileID = FileID::get(Record[0]);
2601  ResolveImportedPath(F, F.OriginalSourceFileName);
2602  break;
2603 
2604  case ORIGINAL_FILE_ID:
2605  F.OriginalSourceFileID = FileID::get(Record[0]);
2606  break;
2607 
2608  case ORIGINAL_PCH_DIR:
2609  F.OriginalDir = Blob;
2610  break;
2611 
2612  case MODULE_NAME:
2613  F.ModuleName = Blob;
2614  if (Listener)
2615  Listener->ReadModuleName(F.ModuleName);
2616 
2617  // Validate the AST as soon as we have a name so we can exit early on
2618  // failure.
2619  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2620  return Result;
2621 
2622  break;
2623 
2624  case MODULE_DIRECTORY: {
2625  assert(!F.ModuleName.empty() &&
2626  "MODULE_DIRECTORY found before MODULE_NAME");
2627  // If we've already loaded a module map file covering this module, we may
2628  // have a better path for it (relative to the current build).
2629  Module *M = PP.getHeaderSearchInfo().lookupModule(
2630  F.ModuleName, /*AllowSearch*/ true,
2631  /*AllowExtraModuleMapSearch*/ true);
2632  if (M && M->Directory) {
2633  // If we're implicitly loading a module, the base directory can't
2634  // change between the build and use.
2635  // Don't emit module relocation error if we have -fno-validate-pch
2636  if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2638  const DirectoryEntry *BuildDir =
2639  PP.getFileManager().getDirectory(Blob);
2640  if (!BuildDir || BuildDir != M->Directory) {
2641  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2642  Diag(diag::err_imported_module_relocated)
2643  << F.ModuleName << Blob << M->Directory->getName();
2644  return OutOfDate;
2645  }
2646  }
2647  F.BaseDirectory = M->Directory->getName();
2648  } else {
2649  F.BaseDirectory = Blob;
2650  }
2651  break;
2652  }
2653 
2654  case MODULE_MAP_FILE:
2655  if (ASTReadResult Result =
2656  ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2657  return Result;
2658  break;
2659 
2660  case INPUT_FILE_OFFSETS:
2661  NumInputs = Record[0];
2662  NumUserInputs = Record[1];
2663  F.InputFileOffsets =
2664  (const llvm::support::unaligned_uint64_t *)Blob.data();
2665  F.InputFilesLoaded.resize(NumInputs);
2666  F.NumUserInputFiles = NumUserInputs;
2667  break;
2668  }
2669  }
2670 }
2671 
2673 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2674  BitstreamCursor &Stream = F.Stream;
2675 
2676  if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2677  Error("malformed block record in AST file");
2678  return Failure;
2679  }
2680 
2681  // Read all of the records and blocks for the AST file.
2682  RecordData Record;
2683  while (true) {
2684  llvm::BitstreamEntry Entry = Stream.advance();
2685 
2686  switch (Entry.Kind) {
2688  Error("error at end of module block in AST file");
2689  return Failure;
2690  case llvm::BitstreamEntry::EndBlock:
2691  // Outside of C++, we do not store a lookup map for the translation unit.
2692  // Instead, mark it as needing a lookup map to be built if this module
2693  // contains any declarations lexically within it (which it always does!).
2694  // This usually has no cost, since we very rarely need the lookup map for
2695  // the translation unit outside C++.
2696  if (ASTContext *Ctx = ContextObj) {
2697  DeclContext *DC = Ctx->getTranslationUnitDecl();
2698  if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2700  }
2701 
2702  return Success;
2703  case llvm::BitstreamEntry::SubBlock:
2704  switch (Entry.ID) {
2705  case DECLTYPES_BLOCK_ID:
2706  // We lazily load the decls block, but we want to set up the
2707  // DeclsCursor cursor to point into it. Clone our current bitcode
2708  // cursor to it, enter the block and read the abbrevs in that block.
2709  // With the main cursor, we just skip over it.
2710  F.DeclsCursor = Stream;
2711  if (Stream.SkipBlock() || // Skip with the main cursor.
2712  // Read the abbrevs.
2713  ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2714  Error("malformed block record in AST file");
2715  return Failure;
2716  }
2717  break;
2718 
2719  case PREPROCESSOR_BLOCK_ID:
2720  F.MacroCursor = Stream;
2721  if (!PP.getExternalSource())
2722  PP.setExternalSource(this);
2723 
2724  if (Stream.SkipBlock() ||
2725  ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2726  Error("malformed block record in AST file");
2727  return Failure;
2728  }
2729  F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2730  break;
2731 
2733  F.PreprocessorDetailCursor = Stream;
2734  if (Stream.SkipBlock() ||
2735  ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2737  Error("malformed preprocessor detail record in AST file");
2738  return Failure;
2739  }
2741  = F.PreprocessorDetailCursor.GetCurrentBitNo();
2742 
2743  if (!PP.getPreprocessingRecord())
2744  PP.createPreprocessingRecord();
2745  if (!PP.getPreprocessingRecord()->getExternalSource())
2746  PP.getPreprocessingRecord()->SetExternalSource(*this);
2747  break;
2748 
2750  if (ReadSourceManagerBlock(F))
2751  return Failure;
2752  break;
2753 
2754  case SUBMODULE_BLOCK_ID:
2755  if (ASTReadResult Result =
2756  ReadSubmoduleBlock(F, ClientLoadCapabilities))
2757  return Result;
2758  break;
2759 
2760  case COMMENTS_BLOCK_ID: {
2761  BitstreamCursor C = Stream;
2762  if (Stream.SkipBlock() ||
2763  ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2764  Error("malformed comments block in AST file");
2765  return Failure;
2766  }
2767  CommentsCursors.push_back(std::make_pair(C, &F));
2768  break;
2769  }
2770 
2771  default:
2772  if (Stream.SkipBlock()) {
2773  Error("malformed block record in AST file");
2774  return Failure;
2775  }
2776  break;
2777  }
2778  continue;
2779 
2780  case llvm::BitstreamEntry::Record:
2781  // The interesting case.
2782  break;
2783  }
2784 
2785  // Read and process a record.
2786  Record.clear();
2787  StringRef Blob;
2788  auto RecordType =
2789  (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2790 
2791  // If we're not loading an AST context, we don't care about most records.
2792  if (!ContextObj) {
2793  switch (RecordType) {
2794  case IDENTIFIER_TABLE:
2795  case IDENTIFIER_OFFSET:
2797  case STATISTICS:
2798  case PP_CONDITIONAL_STACK:
2799  case PP_COUNTER_VALUE:
2801  case MODULE_OFFSET_MAP:
2804  case PPD_ENTITIES_OFFSETS:
2805  case HEADER_SEARCH_TABLE:
2806  case IMPORTED_MODULES:
2807  case MACRO_OFFSET:
2808  break;
2809  default:
2810  continue;
2811  }
2812  }
2813 
2814  switch (RecordType) {
2815  default: // Default behavior: ignore.
2816  break;
2817 
2818  case TYPE_OFFSET: {
2819  if (F.LocalNumTypes != 0) {
2820  Error("duplicate TYPE_OFFSET record in AST file");
2821  return Failure;
2822  }
2823  F.TypeOffsets = (const uint32_t *)Blob.data();
2824  F.LocalNumTypes = Record[0];
2825  unsigned LocalBaseTypeIndex = Record[1];
2826  F.BaseTypeIndex = getTotalNumTypes();
2827 
2828  if (F.LocalNumTypes > 0) {
2829  // Introduce the global -> local mapping for types within this module.
2830  GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2831 
2832  // Introduce the local -> global mapping for types within this module.
2834  std::make_pair(LocalBaseTypeIndex,
2835  F.BaseTypeIndex - LocalBaseTypeIndex));
2836 
2837  TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2838  }
2839  break;
2840  }
2841 
2842  case DECL_OFFSET: {
2843  if (F.LocalNumDecls != 0) {
2844  Error("duplicate DECL_OFFSET record in AST file");
2845  return Failure;
2846  }
2847  F.DeclOffsets = (const DeclOffset *)Blob.data();
2848  F.LocalNumDecls = Record[0];
2849  unsigned LocalBaseDeclID = Record[1];
2850  F.BaseDeclID = getTotalNumDecls();
2851 
2852  if (F.LocalNumDecls > 0) {
2853  // Introduce the global -> local mapping for declarations within this
2854  // module.
2855  GlobalDeclMap.insert(
2856  std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2857 
2858  // Introduce the local -> global mapping for declarations within this
2859  // module.
2861  std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2862 
2863  // Introduce the global -> local mapping for declarations within this
2864  // module.
2865  F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2866 
2867  DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2868  }
2869  break;
2870  }
2871 
2872  case TU_UPDATE_LEXICAL: {
2873  DeclContext *TU = ContextObj->getTranslationUnitDecl();
2874  LexicalContents Contents(
2875  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2876  Blob.data()),
2877  static_cast<unsigned int>(Blob.size() / 4));
2878  TULexicalDecls.push_back(std::make_pair(&F, Contents));
2879  TU->setHasExternalLexicalStorage(true);
2880  break;
2881  }
2882 
2883  case UPDATE_VISIBLE: {
2884  unsigned Idx = 0;
2885  serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2886  auto *Data = (const unsigned char*)Blob.data();
2887  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2888  // If we've already loaded the decl, perform the updates when we finish
2889  // loading this block.
2890  if (Decl *D = GetExistingDecl(ID))
2891  PendingUpdateRecords.push_back(
2892  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2893  break;
2894  }
2895 
2896  case IDENTIFIER_TABLE:
2897  F.IdentifierTableData = Blob.data();
2898  if (Record[0]) {
2900  (const unsigned char *)F.IdentifierTableData + Record[0],
2901  (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2902  (const unsigned char *)F.IdentifierTableData,
2903  ASTIdentifierLookupTrait(*this, F));
2904 
2905  PP.getIdentifierTable().setExternalIdentifierLookup(this);
2906  }
2907  break;
2908 
2909  case IDENTIFIER_OFFSET: {
2910  if (F.LocalNumIdentifiers != 0) {
2911  Error("duplicate IDENTIFIER_OFFSET record in AST file");
2912  return Failure;
2913  }
2914  F.IdentifierOffsets = (const uint32_t *)Blob.data();
2915  F.LocalNumIdentifiers = Record[0];
2916  unsigned LocalBaseIdentifierID = Record[1];
2917  F.BaseIdentifierID = getTotalNumIdentifiers();
2918 
2919  if (F.LocalNumIdentifiers > 0) {
2920  // Introduce the global -> local mapping for identifiers within this
2921  // module.
2922  GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2923  &F));
2924 
2925  // Introduce the local -> global mapping for identifiers within this
2926  // module.
2928  std::make_pair(LocalBaseIdentifierID,
2929  F.BaseIdentifierID - LocalBaseIdentifierID));
2930 
2931  IdentifiersLoaded.resize(IdentifiersLoaded.size()
2932  + F.LocalNumIdentifiers);
2933  }
2934  break;
2935  }
2936 
2938  F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2939  break;
2940 
2942  // FIXME: Skip reading this record if our ASTConsumer doesn't care
2943  // about "interesting" decls (for instance, if we're building a module).
2944  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2945  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2946  break;
2947 
2948  case MODULAR_CODEGEN_DECLS:
2949  // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2950  // them (ie: if we're not codegenerating this module).
2951  if (F.Kind == MK_MainFile)
2952  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2953  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2954  break;
2955 
2956  case SPECIAL_TYPES:
2957  if (SpecialTypes.empty()) {
2958  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2959  SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2960  break;
2961  }
2962 
2963  if (SpecialTypes.size() != Record.size()) {
2964  Error("invalid special-types record");
2965  return Failure;
2966  }
2967 
2968  for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2969  serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2970  if (!SpecialTypes[I])
2971  SpecialTypes[I] = ID;
2972  // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2973  // merge step?
2974  }
2975  break;
2976 
2977  case STATISTICS:
2978  TotalNumStatements += Record[0];
2979  TotalNumMacros += Record[1];
2980  TotalLexicalDeclContexts += Record[2];
2981  TotalVisibleDeclContexts += Record[3];
2982  break;
2983 
2985  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2986  UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2987  break;
2988 
2989  case DELEGATING_CTORS:
2990  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2991  DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2992  break;
2993 
2995  if (Record.size() % 4 != 0) {
2996  Error("invalid weak identifiers record");
2997  return Failure;
2998  }
2999 
3000  // FIXME: Ignore weak undeclared identifiers from non-original PCH
3001  // files. This isn't the way to do it :)
3002  WeakUndeclaredIdentifiers.clear();
3003 
3004  // Translate the weak, undeclared identifiers into global IDs.
3005  for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3006  WeakUndeclaredIdentifiers.push_back(
3007  getGlobalIdentifierID(F, Record[I++]));
3008  WeakUndeclaredIdentifiers.push_back(
3009  getGlobalIdentifierID(F, Record[I++]));
3010  WeakUndeclaredIdentifiers.push_back(
3011  ReadSourceLocation(F, Record, I).getRawEncoding());
3012  WeakUndeclaredIdentifiers.push_back(Record[I++]);
3013  }
3014  break;
3015 
3016  case SELECTOR_OFFSETS: {
3017  F.SelectorOffsets = (const uint32_t *)Blob.data();
3018  F.LocalNumSelectors = Record[0];
3019  unsigned LocalBaseSelectorID = Record[1];
3020  F.BaseSelectorID = getTotalNumSelectors();
3021 
3022  if (F.LocalNumSelectors > 0) {
3023  // Introduce the global -> local mapping for selectors within this
3024  // module.
3025  GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3026 
3027  // Introduce the local -> global mapping for selectors within this
3028  // module.
3030  std::make_pair(LocalBaseSelectorID,
3031  F.BaseSelectorID - LocalBaseSelectorID));
3032 
3033  SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3034  }
3035  break;
3036  }
3037 
3038  case METHOD_POOL:
3039  F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3040  if (Record[0])
3043  F.SelectorLookupTableData + Record[0],
3045  ASTSelectorLookupTrait(*this, F));
3046  TotalNumMethodPoolEntries += Record[1];
3047  break;
3048 
3050  if (!Record.empty()) {
3051  for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3052  ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3053  Record[Idx++]));
3054  ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3055  getRawEncoding());
3056  }
3057  }
3058  break;
3059 
3060  case PP_CONDITIONAL_STACK:
3061  if (!Record.empty()) {
3062  unsigned Idx = 0, End = Record.size() - 1;
3063  bool ReachedEOFWhileSkipping = Record[Idx++];
3065  if (ReachedEOFWhileSkipping) {
3066  SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3067  SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3068  bool FoundNonSkipPortion = Record[Idx++];
3069  bool FoundElse = Record[Idx++];
3070  SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3071  SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3072  FoundElse, ElseLoc);
3073  }
3074  SmallVector<PPConditionalInfo, 4> ConditionalStack;
3075  while (Idx < End) {
3076  auto Loc = ReadSourceLocation(F, Record, Idx);
3077  bool WasSkipping = Record[Idx++];
3078  bool FoundNonSkip = Record[Idx++];
3079  bool FoundElse = Record[Idx++];
3080  ConditionalStack.push_back(
3081  {Loc, WasSkipping, FoundNonSkip, FoundElse});
3082  }
3083  PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3084  }
3085  break;
3086 
3087  case PP_COUNTER_VALUE:
3088  if (!Record.empty() && Listener)
3089  Listener->ReadCounter(F, Record[0]);
3090  break;
3091 
3092  case FILE_SORTED_DECLS:
3093  F.FileSortedDecls = (const DeclID *)Blob.data();
3094  F.NumFileSortedDecls = Record[0];
3095  break;
3096 
3097  case SOURCE_LOCATION_OFFSETS: {
3098  F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3099  F.LocalNumSLocEntries = Record[0];
3100  unsigned SLocSpaceSize = Record[1];
3101  std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3102  SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3103  SLocSpaceSize);
3104  if (!F.SLocEntryBaseID) {
3105  Error("ran out of source locations");
3106  break;
3107  }
3108  // Make our entry in the range map. BaseID is negative and growing, so
3109  // we invert it. Because we invert it, though, we need the other end of
3110  // the range.
3111  unsigned RangeStart =
3112  unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3113  GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3115 
3116  // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3117  assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3118  GlobalSLocOffsetMap.insert(
3119  std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3120  - SLocSpaceSize,&F));
3121 
3122  // Initialize the remapping table.
3123  // Invalid stays invalid.
3124  F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3125  // This module. Base was 2 when being compiled.
3126  F.SLocRemap.insertOrReplace(std::make_pair(2U,
3127  static_cast<int>(F.SLocEntryBaseOffset - 2)));
3128 
3129  TotalNumSLocEntries += F.LocalNumSLocEntries;
3130  break;
3131  }
3132 
3133  case MODULE_OFFSET_MAP:
3134  F.ModuleOffsetMap = Blob;
3135  break;
3136 
3138  if (ParseLineTable(F, Record))
3139  return Failure;
3140  break;
3141 
3142  case SOURCE_LOCATION_PRELOADS: {
3143  // Need to transform from the local view (1-based IDs) to the global view,
3144  // which is based off F.SLocEntryBaseID.
3145  if (!F.PreloadSLocEntries.empty()) {
3146  Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3147  return Failure;
3148  }
3149 
3150  F.PreloadSLocEntries.swap(Record);
3151  break;
3152  }
3153 
3154  case EXT_VECTOR_DECLS:
3155  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3156  ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3157  break;
3158 
3159  case VTABLE_USES:
3160  if (Record.size() % 3 != 0) {
3161  Error("Invalid VTABLE_USES record");
3162  return Failure;
3163  }
3164 
3165  // Later tables overwrite earlier ones.
3166  // FIXME: Modules will have some trouble with this. This is clearly not
3167  // the right way to do this.
3168  VTableUses.clear();
3169 
3170  for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3171  VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3172  VTableUses.push_back(
3173  ReadSourceLocation(F, Record, Idx).getRawEncoding());
3174  VTableUses.push_back(Record[Idx++]);
3175  }
3176  break;
3177 
3179  if (PendingInstantiations.size() % 2 != 0) {
3180  Error("Invalid existing PendingInstantiations");
3181  return Failure;
3182  }
3183 
3184  if (Record.size() % 2 != 0) {
3185  Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3186  return Failure;
3187  }
3188 
3189  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3190  PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3191  PendingInstantiations.push_back(
3192  ReadSourceLocation(F, Record, I).getRawEncoding());
3193  }
3194  break;
3195 
3196  case SEMA_DECL_REFS:
3197  if (Record.size() != 3) {
3198  Error("Invalid SEMA_DECL_REFS block");
3199  return Failure;
3200  }
3201  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3202  SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3203  break;
3204 
3205  case PPD_ENTITIES_OFFSETS: {
3206  F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3207  assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3208  F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3209 
3210  unsigned LocalBasePreprocessedEntityID = Record[0];
3211 
3212  unsigned StartingID;
3213  if (!PP.getPreprocessingRecord())
3214  PP.createPreprocessingRecord();
3215  if (!PP.getPreprocessingRecord()->getExternalSource())
3216  PP.getPreprocessingRecord()->SetExternalSource(*this);
3217  StartingID
3218  = PP.getPreprocessingRecord()
3219  ->allocateLoadedEntities(F.NumPreprocessedEntities);
3220  F.BasePreprocessedEntityID = StartingID;
3221 
3222  if (F.NumPreprocessedEntities > 0) {
3223  // Introduce the global -> local mapping for preprocessed entities in
3224  // this module.
3225  GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3226 
3227  // Introduce the local -> global mapping for preprocessed entities in
3228  // this module.
3230  std::make_pair(LocalBasePreprocessedEntityID,
3231  F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3232  }
3233 
3234  break;
3235  }
3236 
3237  case PPD_SKIPPED_RANGES: {
3238  F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3239  assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3240  F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3241 
3242  if (!PP.getPreprocessingRecord())
3243  PP.createPreprocessingRecord();
3244  if (!PP.getPreprocessingRecord()->getExternalSource())
3245  PP.getPreprocessingRecord()->SetExternalSource(*this);
3246  F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3247  ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3248 
3249  if (F.NumPreprocessedSkippedRanges > 0)
3250  GlobalSkippedRangeMap.insert(
3251  std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3252  break;
3253  }
3254 
3255  case DECL_UPDATE_OFFSETS:
3256  if (Record.size() % 2 != 0) {
3257  Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3258  return Failure;
3259  }
3260  for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3261  GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3262  DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3263 
3264  // If we've already loaded the decl, perform the updates when we finish
3265  // loading this block.
3266  if (Decl *D = GetExistingDecl(ID))
3267  PendingUpdateRecords.push_back(
3268  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3269  }
3270  break;
3271 
3272  case OBJC_CATEGORIES_MAP:
3273  if (F.LocalNumObjCCategoriesInMap != 0) {
3274  Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3275  return Failure;
3276  }
3277 
3278  F.LocalNumObjCCategoriesInMap = Record[0];
3279  F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3280  break;
3281 
3282  case OBJC_CATEGORIES:
3283  F.ObjCCategories.swap(Record);
3284  break;
3285 
3287  // Later tables overwrite earlier ones.
3288  // FIXME: Modules will have trouble with this.
3289  CUDASpecialDeclRefs.clear();
3290  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3291  CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3292  break;
3293 
3294  case HEADER_SEARCH_TABLE:
3295  F.HeaderFileInfoTableData = Blob.data();
3296  F.LocalNumHeaderFileInfos = Record[1];
3297  if (Record[0]) {
3300  (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3301  (const unsigned char *)F.HeaderFileInfoTableData,
3302  HeaderFileInfoTrait(*this, F,
3303  &PP.getHeaderSearchInfo(),
3304  Blob.data() + Record[2]));
3305 
3306  PP.getHeaderSearchInfo().SetExternalSource(this);
3307  if (!PP.getHeaderSearchInfo().getExternalLookup())
3308  PP.getHeaderSearchInfo().SetExternalLookup(this);
3309  }
3310  break;
3311 
3312  case FP_PRAGMA_OPTIONS:
3313  // Later tables overwrite earlier ones.
3314  FPPragmaOptions.swap(Record);
3315  break;
3316 
3317  case OPENCL_EXTENSIONS:
3318  for (unsigned I = 0, E = Record.size(); I != E; ) {
3319  auto Name = ReadString(Record, I);
3320  auto &Opt = OpenCLExtensions.OptMap[Name];
3321  Opt.Supported = Record[I++] != 0;
3322  Opt.Enabled = Record[I++] != 0;
3323  Opt.Avail = Record[I++];
3324  Opt.Core = Record[I++];
3325  }
3326  break;
3327 
3329  for (unsigned I = 0, E = Record.size(); I != E;) {
3330  auto TypeID = static_cast<::TypeID>(Record[I++]);
3331  auto *Type = GetType(TypeID).getTypePtr();
3332  auto NumExt = static_cast<unsigned>(Record[I++]);
3333  for (unsigned II = 0; II != NumExt; ++II) {
3334  auto Ext = ReadString(Record, I);
3335  OpenCLTypeExtMap[Type].insert(Ext);
3336  }
3337  }
3338  break;
3339 
3341  for (unsigned I = 0, E = Record.size(); I != E;) {
3342  auto DeclID = static_cast<::DeclID>(Record[I++]);
3343  auto *Decl = GetDecl(DeclID);
3344  auto NumExt = static_cast<unsigned>(Record[I++]);
3345  for (unsigned II = 0; II != NumExt; ++II) {
3346  auto Ext = ReadString(Record, I);
3347  OpenCLDeclExtMap[Decl].insert(Ext);
3348  }
3349  }
3350  break;
3351 
3352  case TENTATIVE_DEFINITIONS:
3353  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3354  TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3355  break;
3356 
3357  case KNOWN_NAMESPACES:
3358  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3359  KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3360  break;
3361 
3362  case UNDEFINED_BUT_USED:
3363  if (UndefinedButUsed.size() % 2 != 0) {
3364  Error("Invalid existing UndefinedButUsed");
3365  return Failure;
3366  }
3367 
3368  if (Record.size() % 2 != 0) {
3369  Error("invalid undefined-but-used record");
3370  return Failure;
3371  }
3372  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3373  UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3374  UndefinedButUsed.push_back(
3375  ReadSourceLocation(F, Record, I).getRawEncoding());
3376  }
3377  break;
3378 
3380  for (unsigned I = 0, N = Record.size(); I != N;) {
3381  DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3382  const uint64_t Count = Record[I++];
3383  DelayedDeleteExprs.push_back(Count);
3384  for (uint64_t C = 0; C < Count; ++C) {
3385  DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3386  bool IsArrayForm = Record[I++] == 1;
3387  DelayedDeleteExprs.push_back(IsArrayForm);
3388  }
3389  }
3390  break;
3391 
3392  case IMPORTED_MODULES:
3393  if (!F.isModule()) {
3394  // If we aren't loading a module (which has its own exports), make
3395  // all of the imported modules visible.
3396  // FIXME: Deal with macros-only imports.
3397  for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3398  unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3399  SourceLocation Loc = ReadSourceLocation(F, Record, I);
3400  if (GlobalID) {
3401  ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3402  if (DeserializationListener)
3403  DeserializationListener->ModuleImportRead(GlobalID, Loc);
3404  }
3405  }
3406  }
3407  break;
3408 
3409  case MACRO_OFFSET: {
3410  if (F.LocalNumMacros != 0) {
3411  Error("duplicate MACRO_OFFSET record in AST file");
3412  return Failure;
3413  }
3414  F.MacroOffsets = (const uint32_t *)Blob.data();
3415  F.LocalNumMacros = Record[0];
3416  unsigned LocalBaseMacroID = Record[1];
3417  F.BaseMacroID = getTotalNumMacros();
3418 
3419  if (F.LocalNumMacros > 0) {
3420  // Introduce the global -> local mapping for macros within this module.
3421  GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3422 
3423  // Introduce the local -> global mapping for macros within this module.
3425  std::make_pair(LocalBaseMacroID,
3426  F.BaseMacroID - LocalBaseMacroID));
3427 
3428  MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3429  }
3430  break;
3431  }
3432 
3433  case LATE_PARSED_TEMPLATE:
3434  LateParsedTemplates.append(Record.begin(), Record.end());
3435  break;
3436 
3438  if (Record.size() != 1) {
3439  Error("invalid pragma optimize record");
3440  return Failure;
3441  }
3442  OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3443  break;
3444 
3446  if (Record.size() != 1) {
3447  Error("invalid pragma ms_struct record");
3448  return Failure;
3449  }
3450  PragmaMSStructState = Record[0];
3451  break;
3452 
3454  if (Record.size() != 2) {
3455  Error("invalid pragma ms_struct record");
3456  return Failure;
3457  }
3458  PragmaMSPointersToMembersState = Record[0];
3459  PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3460  break;
3461 
3463  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3464  UnusedLocalTypedefNameCandidates.push_back(
3465  getGlobalDeclID(F, Record[I]));
3466  break;
3467 
3469  if (Record.size() != 1) {
3470  Error("invalid cuda pragma options record");
3471  return Failure;
3472  }
3473  ForceCUDAHostDeviceDepth = Record[0];
3474  break;
3475 
3476  case PACK_PRAGMA_OPTIONS: {
3477  if (Record.size() < 3) {
3478  Error("invalid pragma pack record");
3479  return Failure;
3480  }
3481  PragmaPackCurrentValue = Record[0];
3482  PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3483  unsigned NumStackEntries = Record[2];
3484  unsigned Idx = 3;
3485  // Reset the stack when importing a new module.
3486  PragmaPackStack.clear();
3487  for (unsigned I = 0; I < NumStackEntries; ++I) {
3488  PragmaPackStackEntry Entry;
3489  Entry.Value = Record[Idx++];
3490  Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3491  Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3492  PragmaPackStrings.push_back(ReadString(Record, Idx));
3493  Entry.SlotLabel = PragmaPackStrings.back();
3494  PragmaPackStack.push_back(Entry);
3495  }
3496  break;
3497  }
3498  }
3499  }
3500 }
3501 
3502 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3503  assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3504 
3505  // Additional remapping information.
3506  const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3507  const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3508  F.ModuleOffsetMap = StringRef();
3509 
3510  // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3511  if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3512  F.SLocRemap.insert(std::make_pair(0U, 0));
3513  F.SLocRemap.insert(std::make_pair(2U, 1));
3514  }
3515 
3516  // Continuous range maps we may be updating in our module.
3517  using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3518  RemapBuilder SLocRemap(F.SLocRemap);
3519  RemapBuilder IdentifierRemap(F.IdentifierRemap);
3520  RemapBuilder MacroRemap(F.MacroRemap);
3521  RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3522  RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3523  RemapBuilder SelectorRemap(F.SelectorRemap);
3524  RemapBuilder DeclRemap(F.DeclRemap);
3525  RemapBuilder TypeRemap(F.TypeRemap);
3526 
3527  while (Data < DataEnd) {
3528  // FIXME: Looking up dependency modules by filename is horrible. Let's
3529  // start fixing this with prebuilt and explicit modules and see how it
3530  // goes...
3531  using namespace llvm::support;
3532  ModuleKind Kind = static_cast<ModuleKind>(
3533  endian::readNext<uint8_t, little, unaligned>(Data));
3534  uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3535  StringRef Name = StringRef((const char*)Data, Len);
3536  Data += Len;
3537  ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3538  ? ModuleMgr.lookupByModuleName(Name)
3539  : ModuleMgr.lookupByFileName(Name));
3540  if (!OM) {
3541  std::string Msg =
3542  "SourceLocation remap refers to unknown module, cannot find ";
3543  Msg.append(Name);
3544  Error(Msg);
3545  return;
3546  }
3547 
3548  uint32_t SLocOffset =
3549  endian::readNext<uint32_t, little, unaligned>(Data);
3550  uint32_t IdentifierIDOffset =
3551  endian::readNext<uint32_t, little, unaligned>(Data);
3552  uint32_t MacroIDOffset =
3553  endian::readNext<uint32_t, little, unaligned>(Data);
3554  uint32_t PreprocessedEntityIDOffset =
3555  endian::readNext<uint32_t, little, unaligned>(Data);
3556  uint32_t SubmoduleIDOffset =
3557  endian::readNext<uint32_t, little, unaligned>(Data);
3558  uint32_t SelectorIDOffset =
3559  endian::readNext<uint32_t, little, unaligned>(Data);
3560  uint32_t DeclIDOffset =
3561  endian::readNext<uint32_t, little, unaligned>(Data);
3562  uint32_t TypeIndexOffset =
3563  endian::readNext<uint32_t, little, unaligned>(Data);
3564 
3565  uint32_t None = std::numeric_limits<uint32_t>::max();
3566 
3567  auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3568  RemapBuilder &Remap) {
3569  if (Offset != None)
3570  Remap.insert(std::make_pair(Offset,
3571  static_cast<int>(BaseOffset - Offset)));
3572  };
3573  mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3574  mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3575  mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3576  mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3577  PreprocessedEntityRemap);
3578  mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3579  mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3580  mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3581  mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3582 
3583  // Global -> local mappings.
3584  F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3585  }
3586 }
3587 
3589 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3590  const ModuleFile *ImportedBy,
3591  unsigned ClientLoadCapabilities) {
3592  unsigned Idx = 0;
3593  F.ModuleMapPath = ReadPath(F, Record, Idx);
3594 
3595  // Try to resolve ModuleName in the current header search context and
3596  // verify that it is found in the same module map file as we saved. If the
3597  // top-level AST file is a main file, skip this check because there is no
3598  // usable header search context.
3599  assert(!F.ModuleName.empty() &&
3600  "MODULE_NAME should come before MODULE_MAP_FILE");
3601  if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3602  // An implicitly-loaded module file should have its module listed in some
3603  // module map file that we've already loaded.
3604  Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3605  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3606  const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3607  // Don't emit module relocation error if we have -fno-validate-pch
3608  if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3609  assert(ImportedBy && "top-level import should be verified");
3610  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3611  if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3612  // This module was defined by an imported (explicit) module.
3613  Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3614  << ASTFE->getName();
3615  } else {
3616  // This module was built with a different module map.
3617  Diag(diag::err_imported_module_not_found)
3618  << F.ModuleName << F.FileName << ImportedBy->FileName
3619  << F.ModuleMapPath;
3620  // In case it was imported by a PCH, there's a chance the user is
3621  // just missing to include the search path to the directory containing
3622  // the modulemap.
3623  if (ImportedBy->Kind == MK_PCH)
3624  Diag(diag::note_imported_by_pch_module_not_found)
3625  << llvm::sys::path::parent_path(F.ModuleMapPath);
3626  }
3627  }
3628  return OutOfDate;
3629  }
3630 
3631  assert(M->Name == F.ModuleName && "found module with different name");
3632 
3633  // Check the primary module map file.
3634  const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3635  if (StoredModMap == nullptr || StoredModMap != ModMap) {
3636  assert(ModMap && "found module is missing module map file");
3637  assert(ImportedBy && "top-level import should be verified");
3638  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3639  Diag(diag::err_imported_module_modmap_changed)
3640  << F.ModuleName << ImportedBy->FileName
3641  << ModMap->getName() << F.ModuleMapPath;
3642  return OutOfDate;
3643  }
3644 
3645  llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3646  for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3647  // FIXME: we should use input files rather than storing names.
3648  std::string Filename = ReadPath(F, Record, Idx);
3649  const FileEntry *F =
3650  FileMgr.getFile(Filename, false, false);
3651  if (F == nullptr) {
3652  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3653  Error("could not find file '" + Filename +"' referenced by AST file");
3654  return OutOfDate;
3655  }
3656  AdditionalStoredMaps.insert(F);
3657  }
3658 
3659  // Check any additional module map files (e.g. module.private.modulemap)
3660  // that are not in the pcm.
3661  if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3662  for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3663  // Remove files that match
3664  // Note: SmallPtrSet::erase is really remove
3665  if (!AdditionalStoredMaps.erase(ModMap)) {
3666  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3667  Diag(diag::err_module_different_modmap)
3668  << F.ModuleName << /*new*/0 << ModMap->getName();
3669  return OutOfDate;
3670  }
3671  }
3672  }
3673 
3674  // Check any additional module map files that are in the pcm, but not
3675  // found in header search. Cases that match are already removed.
3676  for (const FileEntry *ModMap : AdditionalStoredMaps) {
3677  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3678  Diag(diag::err_module_different_modmap)
3679  << F.ModuleName << /*not new*/1 << ModMap->getName();
3680  return OutOfDate;
3681  }
3682  }
3683 
3684  if (Listener)
3685  Listener->ReadModuleMapFile(F.ModuleMapPath);
3686  return Success;
3687 }
3688 
3689 /// Move the given method to the back of the global list of methods.
3691  // Find the entry for this selector in the method pool.
3692  Sema::GlobalMethodPool::iterator Known
3693  = S.MethodPool.find(Method->getSelector());
3694  if (Known == S.MethodPool.end())
3695  return;
3696 
3697  // Retrieve the appropriate method list.
3698  ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3699  : Known->second.second;
3700  bool Found = false;
3701  for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3702  if (!Found) {
3703  if (List->getMethod() == Method) {
3704  Found = true;
3705  } else {
3706  // Keep searching.
3707  continue;
3708  }
3709  }
3710 
3711  if (List->getNext())
3712  List->setMethod(List->getNext()->getMethod());
3713  else
3714  List->setMethod(Method);
3715  }
3716 }
3717 
3718 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3719  assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3720  for (Decl *D : Names) {
3721  bool wasHidden = D->isHidden();
3722  D->setVisibleDespiteOwningModule();
3723 
3724  if (wasHidden && SemaObj) {
3725  if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3726  moveMethodToBackOfGlobalList(*SemaObj, Method);
3727  }
3728  }
3729  }
3730 }
3731 
3733  Module::NameVisibilityKind NameVisibility,
3734  SourceLocation ImportLoc) {
3735  llvm::SmallPtrSet<Module *, 4> Visited;
3737  Stack.push_back(Mod);
3738  while (!Stack.empty()) {
3739  Mod = Stack.pop_back_val();
3740 
3741  if (NameVisibility <= Mod->NameVisibility) {
3742  // This module already has this level of visibility (or greater), so
3743  // there is nothing more to do.
3744  continue;
3745  }
3746 
3747  if (!Mod->isAvailable()) {
3748  // Modules that aren't available cannot be made visible.
3749  continue;
3750  }
3751 
3752  // Update the module's name visibility.
3753  Mod->NameVisibility = NameVisibility;
3754 
3755  // If we've already deserialized any names from this module,
3756  // mark them as visible.
3757  HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3758  if (Hidden != HiddenNamesMap.end()) {
3759  auto HiddenNames = std::move(*Hidden);
3760  HiddenNamesMap.erase(Hidden);
3761  makeNamesVisible(HiddenNames.second, HiddenNames.first);
3762  assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3763  "making names visible added hidden names");
3764  }
3765 
3766  // Push any exported modules onto the stack to be marked as visible.
3767  SmallVector<Module *, 16> Exports;
3768  Mod->getExportedModules(Exports);
3770  I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3771  Module *Exported = *I;
3772  if (Visited.insert(Exported).second)
3773  Stack.push_back(Exported);
3774  }
3775  }
3776 }
3777 
3778 /// We've merged the definition \p MergedDef into the existing definition
3779 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3780 /// visible.
3782  NamedDecl *MergedDef) {
3783  if (Def->isHidden()) {
3784  // If MergedDef is visible or becomes visible, make the definition visible.
3785  if (!MergedDef->isHidden())
3787  else {
3788  getContext().mergeDefinitionIntoModule(
3789  Def, MergedDef->getImportedOwningModule(),
3790  /*NotifyListeners*/ false);
3791  PendingMergedDefinitionsToDeduplicate.insert(Def);
3792  }
3793  }
3794 }
3795 
3797  if (GlobalIndex)
3798  return false;
3799 
3800  if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3801  !PP.getLangOpts().Modules)
3802  return true;
3803 
3804  // Try to load the global index.
3805  TriedLoadingGlobalIndex = true;
3806  StringRef ModuleCachePath
3807  = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3808  std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3809  = GlobalModuleIndex::readIndex(ModuleCachePath);
3810  if (!Result.first)
3811  return true;
3812 
3813  GlobalIndex.reset(Result.first);
3814  ModuleMgr.setGlobalIndex(GlobalIndex.get());
3815  return false;
3816 }
3817 
3819  return PP.getLangOpts().Modules && UseGlobalIndex &&
3820  !hasGlobalIndex() && TriedLoadingGlobalIndex;
3821 }
3822 
3824  // Overwrite the timestamp file contents so that file's mtime changes.
3825  std::string TimestampFilename = MF.getTimestampFilename();
3826  std::error_code EC;
3827  llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3828  if (EC)
3829  return;
3830  OS << "Timestamp file\n";
3831  OS.close();
3832  OS.clear_error(); // Avoid triggering a fatal error.
3833 }
3834 
3835 /// Given a cursor at the start of an AST file, scan ahead and drop the
3836 /// cursor into the start of the given block ID, returning false on success and
3837 /// true on failure.
3838 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3839  while (true) {
3840  llvm::BitstreamEntry Entry = Cursor.advance();
3841  switch (Entry.Kind) {
3843  case llvm::BitstreamEntry::EndBlock:
3844  return true;
3845 
3846  case llvm::BitstreamEntry::Record:
3847  // Ignore top-level records.
3848  Cursor.skipRecord(Entry.ID);
3849  break;
3850 
3851  case llvm::BitstreamEntry::SubBlock:
3852  if (Entry.ID == BlockID) {
3853  if (Cursor.EnterSubBlock(BlockID))
3854  return true;
3855  // Found it!
3856  return false;
3857  }
3858 
3859  if (Cursor.SkipBlock())
3860  return true;
3861  }
3862  }
3863 }
3864 
3866  ModuleKind Type,
3867  SourceLocation ImportLoc,
3868  unsigned ClientLoadCapabilities,
3871  SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3872 
3873  // Defer any pending actions until we get to the end of reading the AST file.
3874  Deserializing AnASTFile(this);
3875 
3876  // Bump the generation number.
3877  unsigned PreviousGeneration = 0;
3878  if (ContextObj)
3879  PreviousGeneration = incrementGeneration(*ContextObj);
3880 
3881  unsigned NumModules = ModuleMgr.size();
3883  switch (ASTReadResult ReadResult =
3884  ReadASTCore(FileName, Type, ImportLoc,
3885  /*ImportedBy=*/nullptr, Loaded, 0, 0,
3886  ASTFileSignature(), ClientLoadCapabilities)) {
3887  case Failure:
3888  case Missing:
3889  case OutOfDate:
3890  case VersionMismatch:
3891  case ConfigurationMismatch:
3892  case HadErrors: {
3893  llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3894  for (const ImportedModule &IM : Loaded)
3895  LoadedSet.insert(IM.Mod);
3896 
3897  ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3898  PP.getLangOpts().Modules
3899  ? &PP.getHeaderSearchInfo().getModuleMap()
3900  : nullptr);
3901 
3902  // If we find that any modules are unusable, the global index is going
3903  // to be out-of-date. Just remove it.
3904  GlobalIndex.reset();
3905  ModuleMgr.setGlobalIndex(nullptr);
3906  return ReadResult;
3907  }
3908  case Success:
3909  break;
3910  }
3911 
3912  // Here comes stuff that we only do once the entire chain is loaded.
3913 
3914  // Load the AST blocks of all of the modules that we loaded.
3915  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3916  MEnd = Loaded.end();
3917  M != MEnd; ++M) {
3918  ModuleFile &F = *M->Mod;
3919 
3920  // Read the AST block.
3921  if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3922  return Result;
3923 
3924  // Read the extension blocks.
3926  if (ASTReadResult Result = ReadExtensionBlock(F))
3927  return Result;
3928  }
3929 
3930  // Once read, set the ModuleFile bit base offset and update the size in
3931  // bits of all files we've seen.
3932  F.GlobalBitOffset = TotalModulesSizeInBits;
3933  TotalModulesSizeInBits += F.SizeInBits;
3934  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3935 
3936  // Preload SLocEntries.
3937  for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3938  int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3939  // Load it through the SourceManager and don't call ReadSLocEntry()
3940  // directly because the entry may have already been loaded in which case
3941  // calling ReadSLocEntry() directly would trigger an assertion in
3942  // SourceManager.
3943  SourceMgr.getLoadedSLocEntryByID(Index);
3944  }
3945 
3946  // Map the original source file ID into the ID space of the current
3947  // compilation.
3948  if (F.OriginalSourceFileID.isValid()) {
3949  F.OriginalSourceFileID = FileID::get(
3950  F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3951  }
3952 
3953  // Preload all the pending interesting identifiers by marking them out of
3954  // date.
3955  for (auto Offset : F.PreloadIdentifierOffsets) {
3956  const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3958 
3959  ASTIdentifierLookupTrait Trait(*this, F);
3960  auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3961  auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3962  auto &II = PP.getIdentifierTable().getOwn(Key);
3963  II.setOutOfDate(true);
3964 
3965  // Mark this identifier as being from an AST file so that we can track
3966  // whether we need to serialize it.
3967  markIdentifierFromAST(*this, II);
3968 
3969  // Associate the ID with the identifier so that the writer can reuse it.
3970  auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3971  SetIdentifierInfo(ID, &II);
3972  }
3973  }
3974 
3975  // Setup the import locations and notify the module manager that we've
3976  // committed to these module files.
3977  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3978  MEnd = Loaded.end();
3979  M != MEnd; ++M) {
3980  ModuleFile &F = *M->Mod;
3981 
3982  ModuleMgr.moduleFileAccepted(&F);
3983 
3984  // Set the import location.
3985  F.DirectImportLoc = ImportLoc;
3986  // FIXME: We assume that locations from PCH / preamble do not need
3987  // any translation.
3988  if (!M->ImportedBy)
3989  F.ImportLoc = M->ImportLoc;
3990  else
3991  F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3992  }
3993 
3994  if (!PP.getLangOpts().CPlusPlus ||
3995  (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
3996  Type != MK_PrebuiltModule)) {
3997  // Mark all of the identifiers in the identifier table as being out of date,
3998  // so that various accessors know to check the loaded modules when the
3999  // identifier is used.
4000  //
4001  // For C++ modules, we don't need information on many identifiers (just
4002  // those that provide macros or are poisoned), so we mark all of
4003  // the interesting ones via PreloadIdentifierOffsets.
4004  for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4005  IdEnd = PP.getIdentifierTable().end();
4006  Id != IdEnd; ++Id)
4007  Id->second->setOutOfDate(true);
4008  }
4009  // Mark selectors as out of date.
4010  for (auto Sel : SelectorGeneration)
4011  SelectorOutOfDate[Sel.first] = true;
4012 
4013  // Resolve any unresolved module exports.
4014  for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4015  UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4016  SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4017  Module *ResolvedMod = getSubmodule(GlobalID);
4018 
4019  switch (Unresolved.Kind) {
4020  case UnresolvedModuleRef::Conflict:
4021  if (ResolvedMod) {
4022  Module::Conflict Conflict;
4023  Conflict.Other = ResolvedMod;
4024  Conflict.Message = Unresolved.String.str();
4025  Unresolved.Mod->Conflicts.push_back(Conflict);
4026  }
4027  continue;
4028 
4029  case UnresolvedModuleRef::Import:
4030  if (ResolvedMod)
4031  Unresolved.Mod->Imports.insert(ResolvedMod);
4032  continue;
4033 
4034  case UnresolvedModuleRef::Export:
4035  if (ResolvedMod || Unresolved.IsWildcard)
4036  Unresolved.Mod->Exports.push_back(
4037  Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4038  continue;
4039  }
4040  }
4041  UnresolvedModuleRefs.clear();
4042 
4043  if (Imported)
4044  Imported->append(ImportedModules.begin(),
4045  ImportedModules.end());
4046 
4047  // FIXME: How do we load the 'use'd modules? They may not be submodules.
4048  // Might be unnecessary as use declarations are only used to build the
4049  // module itself.
4050 
4051  if (ContextObj)
4052  InitializeContext();
4053 
4054  if (SemaObj)
4055  UpdateSema();
4056 
4057  if (DeserializationListener)
4058  DeserializationListener->ReaderInitialized(this);
4059 
4060  ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4061  if (PrimaryModule.OriginalSourceFileID.isValid()) {
4062  // If this AST file is a precompiled preamble, then set the
4063  // preamble file ID of the source manager to the file source file
4064  // from which the preamble was built.
4065  if (Type == MK_Preamble) {
4066  SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4067  } else if (Type == MK_MainFile) {
4068  SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4069  }
4070  }
4071 
4072  // For any Objective-C class definitions we have already loaded, make sure
4073  // that we load any additional categories.
4074  if (ContextObj) {
4075  for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4076  loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4077  ObjCClassesLoaded[I],
4078  PreviousGeneration);
4079  }
4080  }
4081 
4082  if (PP.getHeaderSearchInfo()
4083  .getHeaderSearchOpts()
4084  .ModulesValidateOncePerBuildSession) {
4085  // Now we are certain that the module and all modules it depends on are
4086  // up to date. Create or update timestamp files for modules that are
4087  // located in the module cache (not for PCH files that could be anywhere
4088  // in the filesystem).
4089  for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4090  ImportedModule &M = Loaded[I];
4091  if (M.Mod->Kind == MK_ImplicitModule) {
4092  updateModuleTimestamp(*M.Mod);
4093  }
4094  }
4095  }
4096 
4097  return Success;
4098 }
4099 
4100 static ASTFileSignature readASTFileSignature(StringRef PCH);
4101 
4102 /// Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4103 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4104  return Stream.canSkipToPos(4) &&
4105  Stream.Read(8) == 'C' &&
4106  Stream.Read(8) == 'P' &&
4107  Stream.Read(8) == 'C' &&
4108  Stream.Read(8) == 'H';
4109 }
4110 
4112  switch (Kind) {
4113  case MK_PCH:
4114  return 0; // PCH
4115  case MK_ImplicitModule:
4116  case MK_ExplicitModule:
4117  case MK_PrebuiltModule:
4118  return 1; // module
4119  case MK_MainFile:
4120  case MK_Preamble:
4121  return 2; // main source file
4122  }
4123  llvm_unreachable("unknown module kind");
4124 }
4125 
4127 ASTReader::ReadASTCore(StringRef FileName,
4128  ModuleKind Type,
4129  SourceLocation ImportLoc,
4130  ModuleFile *ImportedBy,
4132  off_t ExpectedSize, time_t ExpectedModTime,
4133  ASTFileSignature ExpectedSignature,
4134  unsigned ClientLoadCapabilities) {
4135  ModuleFile *M;
4136  std::string ErrorStr;
4138  = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4139  getGeneration(), ExpectedSize, ExpectedModTime,
4140  ExpectedSignature, readASTFileSignature,
4141  M, ErrorStr);
4142 
4143  switch (AddResult) {
4145  return Success;
4146 
4148  // Load module file below.
4149  break;
4150 
4152  // The module file was missing; if the client can handle that, return
4153  // it.
4154  if (ClientLoadCapabilities & ARR_Missing)
4155  return Missing;
4156 
4157  // Otherwise, return an error.
4158  Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4159  << FileName << !ErrorStr.empty()
4160  << ErrorStr;
4161  return Failure;
4162 
4164  // We couldn't load the module file because it is out-of-date. If the
4165  // client can handle out-of-date, return it.
4166  if (ClientLoadCapabilities & ARR_OutOfDate)
4167  return OutOfDate;
4168 
4169  // Otherwise, return an error.
4170  Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4171  << FileName << !ErrorStr.empty()
4172  << ErrorStr;
4173  return Failure;
4174  }
4175 
4176  assert(M && "Missing module file");
4177 
4178  ModuleFile &F = *M;
4179  BitstreamCursor &Stream = F.Stream;
4180  Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4181  F.SizeInBits = F.Buffer->getBufferSize() * 8;
4182 
4183  // Sniff for the signature.
4184  if (!startsWithASTFileMagic(Stream)) {
4185  Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4186  << FileName;
4187  return Failure;
4188  }
4189 
4190  // This is used for compatibility with older PCH formats.
4191  bool HaveReadControlBlock = false;
4192  while (true) {
4193  llvm::BitstreamEntry Entry = Stream.advance();
4194 
4195  switch (Entry.Kind) {
4197  case llvm::BitstreamEntry::Record:
4198  case llvm::BitstreamEntry::EndBlock:
4199  Error("invalid record at top-level of AST file");
4200  return Failure;
4201 
4202  case llvm::BitstreamEntry::SubBlock:
4203  break;
4204  }
4205 
4206  switch (Entry.ID) {
4207  case CONTROL_BLOCK_ID:
4208  HaveReadControlBlock = true;
4209  switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4210  case Success:
4211  // Check that we didn't try to load a non-module AST file as a module.
4212  //
4213  // FIXME: Should we also perform the converse check? Loading a module as
4214  // a PCH file sort of works, but it's a bit wonky.
4215  if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4216  Type == MK_PrebuiltModule) &&
4217  F.ModuleName.empty()) {
4218  auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4219  if (Result != OutOfDate ||
4220  (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4221  Diag(diag::err_module_file_not_module) << FileName;
4222  return Result;
4223  }
4224  break;
4225 
4226  case Failure: return Failure;
4227  case Missing: return Missing;
4228  case OutOfDate: return OutOfDate;
4229  case VersionMismatch: return VersionMismatch;
4230  case ConfigurationMismatch: return ConfigurationMismatch;
4231  case HadErrors: return HadErrors;
4232  }
4233  break;
4234 
4235  case AST_BLOCK_ID:
4236  if (!HaveReadControlBlock) {
4237  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4238  Diag(diag::err_pch_version_too_old);
4239  return VersionMismatch;
4240  }
4241 
4242  // Record that we've loaded this module.
4243  Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4244  return Success;
4245 
4247  // This block is handled using look-ahead during ReadControlBlock. We
4248  // shouldn't get here!
4249  Error("malformed block record in AST file");
4250  return Failure;
4251 
4252  default:
4253  if (Stream.SkipBlock()) {
4254  Error("malformed block record in AST file");
4255  return Failure;
4256  }
4257  break;
4258  }
4259  }
4260 
4261  return Success;
4262 }
4263 
4265 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4266  unsigned ClientLoadCapabilities) {
4267  const HeaderSearchOptions &HSOpts =
4268  PP.getHeaderSearchInfo().getHeaderSearchOpts();
4269  bool AllowCompatibleConfigurationMismatch =
4271 
4272  ASTReadResult Result = readUnhashedControlBlockImpl(
4273  &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4274  Listener.get(),
4275  WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4276 
4277  // If F was directly imported by another module, it's implicitly validated by
4278  // the importing module.
4279  if (DisableValidation || WasImportedBy ||
4280  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4281  return Success;
4282 
4283  if (Result == Failure) {
4284  Error("malformed block record in AST file");
4285  return Failure;
4286  }
4287 
4288  if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4289  // If this module has already been finalized in the PCMCache, we're stuck
4290  // with it; we can only load a single version of each module.
4291  //
4292  // This can happen when a module is imported in two contexts: in one, as a
4293  // user module; in another, as a system module (due to an import from
4294  // another module marked with the [system] flag). It usually indicates a
4295  // bug in the module map: this module should also be marked with [system].
4296  //
4297  // If -Wno-system-headers (the default), and the first import is as a
4298  // system module, then validation will fail during the as-user import,
4299  // since -Werror flags won't have been validated. However, it's reasonable
4300  // to treat this consistently as a system module.
4301  //
4302  // If -Wsystem-headers, the PCM on disk was built with
4303  // -Wno-system-headers, and the first import is as a user module, then
4304  // validation will fail during the as-system import since the PCM on disk
4305  // doesn't guarantee that -Werror was respected. However, the -Werror
4306  // flags were checked during the initial as-user import.
4307  if (PCMCache.isBufferFinal(F.FileName)) {
4308  Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4309  return Success;
4310  }
4311  }
4312 
4313  return Result;
4314 }
4315 
4316 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4317  ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4318  bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4319  bool ValidateDiagnosticOptions) {
4320  // Initialize a stream.
4321  BitstreamCursor Stream(StreamData);
4322 
4323  // Sniff for the signature.
4324  if (!startsWithASTFileMagic(Stream))
4325  return Failure;
4326 
4327  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4329  return Failure;
4330 
4331  // Read all of the records in the options block.
4332  RecordData Record;
4333  ASTReadResult Result = Success;
4334  while (true) {
4335  llvm::BitstreamEntry Entry = Stream.advance();
4336 
4337  switch (Entry.Kind) {
4339  case llvm::BitstreamEntry::SubBlock:
4340  return Failure;
4341 
4342  case llvm::BitstreamEntry::EndBlock:
4343  return Result;
4344 
4345  case llvm::BitstreamEntry::Record:
4346  // The interesting case.
4347  break;
4348  }
4349 
4350  // Read and process a record.
4351  Record.clear();
4352  switch (
4353  (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4354  case SIGNATURE:
4355  if (F)
4356  std::copy(Record.begin(), Record.end(), F->Signature.data());
4357  break;
4358  case DIAGNOSTIC_OPTIONS: {
4359  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4360  if (Listener && ValidateDiagnosticOptions &&
4361  !AllowCompatibleConfigurationMismatch &&
4362  ParseDiagnosticOptions(Record, Complain, *Listener))
4363  Result = OutOfDate; // Don't return early. Read the signature.
4364  break;
4365  }
4366  case DIAG_PRAGMA_MAPPINGS:
4367  if (!F)
4368  break;
4369  if (F->PragmaDiagMappings.empty())
4370  F->PragmaDiagMappings.swap(Record);
4371  else
4372  F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4373  Record.begin(), Record.end());
4374  break;
4375  }
4376  }
4377 }
4378 
4379 /// Parse a record and blob containing module file extension metadata.
4381  const SmallVectorImpl<uint64_t> &Record,
4382  StringRef Blob,
4383  ModuleFileExtensionMetadata &Metadata) {
4384  if (Record.size() < 4) return true;
4385 
4386  Metadata.MajorVersion = Record[0];
4387  Metadata.MinorVersion = Record[1];
4388 
4389  unsigned BlockNameLen = Record[2];
4390  unsigned UserInfoLen = Record[3];
4391 
4392  if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4393 
4394  Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4395  Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4396  Blob.data() + BlockNameLen + UserInfoLen);
4397  return false;
4398 }
4399 
4400 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4401  BitstreamCursor &Stream = F.Stream;
4402 
4403  RecordData Record;
4404  while (true) {
4405  llvm::BitstreamEntry Entry = Stream.advance();
4406  switch (Entry.Kind) {
4407  case llvm::BitstreamEntry::SubBlock:
4408  if (Stream.SkipBlock())
4409  return Failure;
4410 
4411  continue;
4412 
4413  case llvm::BitstreamEntry::EndBlock:
4414  return Success;
4415 
4417  return HadErrors;
4418 
4419  case llvm::BitstreamEntry::Record:
4420  break;
4421  }
4422 
4423  Record.clear();
4424  StringRef Blob;
4425  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4426  switch (RecCode) {
4427  case EXTENSION_METADATA: {
4428  ModuleFileExtensionMetadata Metadata;
4429  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4430  return Failure;
4431 
4432  // Find a module file extension with this block name.
4433  auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4434  if (Known == ModuleFileExtensions.end()) break;
4435 
4436  // Form a reader.
4437  if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4438  F, Stream)) {
4439  F.ExtensionReaders.push_back(std::move(Reader));
4440  }
4441 
4442  break;
4443  }
4444  }
4445  }
4446 
4447  return Success;
4448 }
4449 
4451  assert(ContextObj && "no context to initialize");
4452  ASTContext &Context = *ContextObj;
4453 
4454  // If there's a listener, notify them that we "read" the translation unit.
4455  if (DeserializationListener)
4456  DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4457  Context.getTranslationUnitDecl());
4458 
4459  // FIXME: Find a better way to deal with collisions between these
4460  // built-in types. Right now, we just ignore the problem.
4461 
4462  // Load the special types.
4463  if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4464  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4465  if (!Context.CFConstantStringTypeDecl)
4466  Context.setCFConstantStringType(GetType(String));
4467  }
4468 
4469  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4470  QualType FileType = GetType(File);
4471  if (FileType.isNull()) {
4472  Error("FILE type is NULL");
4473  return;
4474  }
4475 
4476  if (!Context.FILEDecl) {
4477  if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4478  Context.setFILEDecl(Typedef->getDecl());
4479  else {
4480  const TagType *Tag = FileType->getAs<TagType>();
4481  if (!Tag) {
4482  Error("Invalid FILE type in AST file");
4483  return;
4484  }
4485  Context.setFILEDecl(Tag->getDecl());
4486  }
4487  }
4488  }
4489 
4490  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4491  QualType Jmp_bufType = GetType(Jmp_buf);
4492  if (Jmp_bufType.isNull()) {
4493  Error("jmp_buf type is NULL");
4494  return;
4495  }
4496 
4497  if (!Context.jmp_bufDecl) {
4498  if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4499  Context.setjmp_bufDecl(Typedef->getDecl());
4500  else {
4501  const TagType *Tag = Jmp_bufType->getAs<TagType>();
4502  if (!Tag) {
4503  Error("Invalid jmp_buf type in AST file");
4504  return;
4505  }
4506  Context.setjmp_bufDecl(Tag->getDecl());
4507  }
4508  }
4509  }
4510 
4511  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4512  QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4513  if (Sigjmp_bufType.isNull()) {
4514  Error("sigjmp_buf type is NULL");
4515  return;
4516  }
4517 
4518  if (!Context.sigjmp_bufDecl) {
4519  if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4520  Context.setsigjmp_bufDecl(Typedef->getDecl());
4521  else {
4522  const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4523  assert(Tag && "Invalid sigjmp_buf type in AST file");
4524  Context.setsigjmp_bufDecl(Tag->getDecl());
4525  }
4526  }
4527  }
4528 
4529  if (unsigned ObjCIdRedef
4530  = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4531  if (Context.ObjCIdRedefinitionType.isNull())
4532  Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4533  }
4534 
4535  if (unsigned ObjCClassRedef
4536  = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4537  if (Context.ObjCClassRedefinitionType.isNull())
4538  Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4539  }
4540 
4541  if (unsigned ObjCSelRedef
4542  = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4543  if (Context.ObjCSelRedefinitionType.isNull())
4544  Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4545  }
4546 
4547  if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4548  QualType Ucontext_tType = GetType(Ucontext_t);
4549  if (Ucontext_tType.isNull()) {
4550  Error("ucontext_t type is NULL");
4551  return;
4552  }
4553 
4554  if (!Context.ucontext_tDecl) {
4555  if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4556  Context.setucontext_tDecl(Typedef->getDecl());
4557  else {
4558  const TagType *Tag = Ucontext_tType->getAs<TagType>();
4559  assert(Tag && "Invalid ucontext_t type in AST file");
4560  Context.setucontext_tDecl(Tag->getDecl());
4561  }
4562  }
4563  }
4564  }
4565 
4566  ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4567 
4568  // If there were any CUDA special declarations, deserialize them.
4569  if (!CUDASpecialDeclRefs.empty()) {
4570  assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4571  Context.setcudaConfigureCallDecl(
4572  cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4573  }
4574 
4575  // Re-export any modules that were imported by a non-module AST file.
4576  // FIXME: This does not make macro-only imports visible again.
4577  for (auto &Import : ImportedModules) {
4578  if (Module *Imported = getSubmodule(Import.ID)) {
4579  makeModuleVisible(Imported, Module::AllVisible,
4580  /*ImportLoc=*/Import.ImportLoc);
4581  if (Import.ImportLoc.isValid())
4582  PP.makeModuleVisible(Imported, Import.ImportLoc);
4583  // FIXME: should we tell Sema to make the module visible too?
4584  }
4585  }
4586  ImportedModules.clear();
4587 }
4588 
4590  // Nothing to do for now.
4591 }
4592 
4593 /// Reads and return the signature record from \p PCH's control block, or
4594 /// else returns 0.
4596  BitstreamCursor Stream(PCH);
4597  if (!startsWithASTFileMagic(Stream))
4598  return ASTFileSignature();
4599 
4600  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4602  return ASTFileSignature();
4603 
4604  // Scan for SIGNATURE inside the diagnostic options block.
4605  ASTReader::RecordData Record;
4606  while (true) {
4607  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4608  if (Entry.Kind != llvm::BitstreamEntry::Record)
4609  return ASTFileSignature();
4610 
4611  Record.clear();
4612  StringRef Blob;
4613  if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4614  return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4615  (uint32_t)Record[3], (uint32_t)Record[4]}}};
4616  }
4617 }
4618 
4619 /// Retrieve the name of the original source file name
4620 /// directly from the AST file, without actually loading the AST
4621 /// file.
4623  const std::string &ASTFileName, FileManager &FileMgr,
4624  const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4625  // Open the AST file.
4626  auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4627  if (!Buffer) {
4628  Diags.Report(diag::err_fe_unable_to_read_pch_file)
4629  << ASTFileName << Buffer.getError().message();
4630  return std::string();
4631  }
4632 
4633  // Initialize the stream
4634  BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4635 
4636  // Sniff for the signature.
4637  if (!startsWithASTFileMagic(Stream)) {
4638  Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4639  return std::string();
4640  }
4641 
4642  // Scan for the CONTROL_BLOCK_ID block.
4643  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4644  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4645  return std::string();
4646  }
4647 
4648  // Scan for ORIGINAL_FILE inside the control block.
4649  RecordData Record;
4650  while (true) {
4651  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4652  if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4653  return std::string();
4654 
4655  if (Entry.Kind != llvm::BitstreamEntry::Record) {
4656  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4657  return std::string();
4658  }
4659 
4660  Record.clear();
4661  StringRef Blob;
4662  if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4663  return Blob.str();
4664  }
4665 }
4666 
4667 namespace {
4668 
4669  class SimplePCHValidator : public ASTReaderListener {
4670  const LangOptions &ExistingLangOpts;
4671  const TargetOptions &ExistingTargetOpts;
4672  const PreprocessorOptions &ExistingPPOpts;
4673  std::string ExistingModuleCachePath;
4674  FileManager &FileMgr;
4675 
4676  public:
4677  SimplePCHValidator(const LangOptions &ExistingLangOpts,
4678  const TargetOptions &ExistingTargetOpts,
4679  const PreprocessorOptions &ExistingPPOpts,
4680  StringRef ExistingModuleCachePath,
4681  FileManager &FileMgr)
4682  : ExistingLangOpts(ExistingLangOpts),
4683  ExistingTargetOpts(ExistingTargetOpts),
4684  ExistingPPOpts(ExistingPPOpts),
4685  ExistingModuleCachePath(ExistingModuleCachePath),
4686  FileMgr(FileMgr) {}
4687 
4688  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4689  bool AllowCompatibleDifferences) override {
4690  return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4691  AllowCompatibleDifferences);
4692  }
4693 
4694  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4695  bool AllowCompatibleDifferences) override {
4696  return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4697  AllowCompatibleDifferences);
4698  }
4699 
4700  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4701  StringRef SpecificModuleCachePath,
4702  bool Complain) override {
4703  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4704  ExistingModuleCachePath,
4705  nullptr, ExistingLangOpts);
4706  }
4707 
4708  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4709  bool Complain,
4710  std::string &SuggestedPredefines) override {
4711  return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4712  SuggestedPredefines, ExistingLangOpts);
4713  }
4714  };
4715 
4716 } // namespace
4717 
4719  StringRef Filename, FileManager &FileMgr,
4720  const PCHContainerReader &PCHContainerRdr,
4721  bool FindModuleFileExtensions,
4722  ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4723  // Open the AST file.
4724  // FIXME: This allows use of the VFS; we do not allow use of the
4725  // VFS when actually loading a module.
4726  auto Buffer = FileMgr.getBufferForFile(Filename);
4727  if (!Buffer) {
4728  return true;
4729  }
4730 
4731  // Initialize the stream
4732  StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4733  BitstreamCursor Stream(Bytes);
4734 
4735  // Sniff for the signature.
4736  if (!startsWithASTFileMagic(Stream))
4737  return true;
4738 
4739  // Scan for the CONTROL_BLOCK_ID block.
4740  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4741  return true;
4742 
4743  bool NeedsInputFiles = Listener.needsInputFileVisitation();
4744  bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4745  bool NeedsImports = Listener.needsImportVisitation();
4746  BitstreamCursor InputFilesCursor;
4747 
4748  RecordData Record;
4749  std::string ModuleDir;
4750  bool DoneWithControlBlock = false;
4751  while (!DoneWithControlBlock) {
4752  llvm::BitstreamEntry Entry = Stream.advance();
4753 
4754  switch (Entry.Kind) {
4755  case llvm::BitstreamEntry::SubBlock: {
4756  switch (Entry.ID) {
4757  case OPTIONS_BLOCK_ID: {
4758  std::string IgnoredSuggestedPredefines;
4759  if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4760  /*AllowCompatibleConfigurationMismatch*/ false,
4761  Listener, IgnoredSuggestedPredefines) != Success)
4762  return true;
4763  break;
4764  }
4765 
4766  case INPUT_FILES_BLOCK_ID:
4767  InputFilesCursor = Stream;
4768  if (Stream.SkipBlock() ||
4769  (NeedsInputFiles &&
4770  ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4771  return true;
4772  break;
4773 
4774  default:
4775  if (Stream.SkipBlock())
4776  return true;
4777  break;
4778  }
4779 
4780  continue;
4781  }
4782 
4783  case llvm::BitstreamEntry::EndBlock:
4784  DoneWithControlBlock = true;
4785  break;
4786 
4788  return true;
4789 
4790  case llvm::BitstreamEntry::Record:
4791  break;
4792  }
4793 
4794  if (DoneWithControlBlock) break;
4795 
4796  Record.clear();
4797  StringRef Blob;
4798  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4799  switch ((ControlRecordTypes)RecCode) {
4800  case METADATA:
4801  if (Record[0] != VERSION_MAJOR)
4802  return true;
4803  if (Listener.ReadFullVersionInformation(Blob))
4804  return true;
4805  break;
4806  case MODULE_NAME:
4807  Listener.ReadModuleName(Blob);
4808  break;
4809  case MODULE_DIRECTORY:
4810  ModuleDir = Blob;
4811  break;
4812  case MODULE_MAP_FILE: {
4813  unsigned Idx = 0;
4814  auto Path = ReadString(Record, Idx);
4815  ResolveImportedPath(Path, ModuleDir);
4816  Listener.ReadModuleMapFile(Path);
4817  break;
4818  }
4819  case INPUT_FILE_OFFSETS: {
4820  if (!NeedsInputFiles)
4821  break;
4822 
4823  unsigned NumInputFiles = Record[0];
4824  unsigned NumUserFiles = Record[1];
4825  const llvm::support::unaligned_uint64_t *InputFileOffs =
4826  (const llvm::support::unaligned_uint64_t *)Blob.data();
4827  for (unsigned I = 0; I != NumInputFiles; ++I) {
4828  // Go find this input file.
4829  bool isSystemFile = I >= NumUserFiles;
4830 
4831  if (isSystemFile && !NeedsSystemInputFiles)
4832  break; // the rest are system input files
4833 
4834  BitstreamCursor &Cursor = InputFilesCursor;
4835  SavedStreamPosition SavedPosition(Cursor);
4836  Cursor.JumpToBit(InputFileOffs[I]);
4837 
4838  unsigned Code = Cursor.ReadCode();
4839  RecordData Record;
4840  StringRef Blob;
4841  bool shouldContinue = false;
4842  switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4843  case INPUT_FILE:
4844  bool Overridden = static_cast<bool>(Record[3]);
4845  std::string Filename = Blob;
4846  ResolveImportedPath(Filename, ModuleDir);
4847  shouldContinue = Listener.visitInputFile(
4848  Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4849  break;
4850  }
4851  if (!shouldContinue)
4852  break;
4853  }
4854  break;
4855  }
4856 
4857  case IMPORTS: {
4858  if (!NeedsImports)
4859  break;
4860 
4861  unsigned Idx = 0, N = Record.size();
4862  while (Idx < N) {
4863  // Read information about the AST file.
4864  Idx += 1+1+1+1+5; // Kind, ImportLoc, Size, ModTime, Signature
4865  std::string ModuleName = ReadString(Record, Idx);
4866  std::string Filename = ReadString(Record, Idx);
4867  ResolveImportedPath(Filename, ModuleDir);
4868  Listener.visitImport(ModuleName, Filename);
4869  }
4870  break;
4871  }
4872 
4873  default:
4874  // No other validation to perform.
4875  break;
4876  }
4877  }
4878 
4879  // Look for module file extension blocks, if requested.
4880  if (FindModuleFileExtensions) {
4881  BitstreamCursor SavedStream = Stream;
4882  while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4883  bool DoneWithExtensionBlock = false;
4884  while (!DoneWithExtensionBlock) {
4885  llvm::BitstreamEntry Entry = Stream.advance();
4886 
4887  switch (Entry.Kind) {
4888  case llvm::BitstreamEntry::SubBlock:
4889  if (Stream.SkipBlock())
4890  return true;
4891 
4892  continue;
4893 
4894  case llvm::BitstreamEntry::EndBlock:
4895  DoneWithExtensionBlock = true;
4896  continue;
4897 
4899  return true;
4900 
4901  case llvm::BitstreamEntry::Record:
4902  break;
4903  }
4904 
4905  Record.clear();
4906  StringRef Blob;
4907  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4908  switch (RecCode) {
4909  case EXTENSION_METADATA: {
4910  ModuleFileExtensionMetadata Metadata;
4911  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4912  return true;
4913 
4914  Listener.readModuleFileExtension(Metadata);
4915  break;
4916  }
4917  }
4918  }
4919  }
4920  Stream = SavedStream;
4921  }
4922 
4923  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4924  if (readUnhashedControlBlockImpl(
4925  nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4926  /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4927  ValidateDiagnosticOptions) != Success)
4928  return true;
4929 
4930  return false;
4931 }
4932 
4934  const PCHContainerReader &PCHContainerRdr,
4935  const LangOptions &LangOpts,
4936  const TargetOptions &TargetOpts,
4937  const PreprocessorOptions &PPOpts,
4938  StringRef ExistingModuleCachePath) {
4939  SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4940  ExistingModuleCachePath, FileMgr);
4941  return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4942  /*FindModuleFileExtensions=*/false,
4943  validator,
4944  /*ValidateDiagnosticOptions=*/true);
4945 }
4946 
4948 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4949  // Enter the submodule block.
4950  if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4951  Error("malformed submodule block record in AST file");
4952  return Failure;
4953  }
4954 
4955  ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4956  bool First = true;
4957  Module *CurrentModule = nullptr;
4958  RecordData Record;
4959  while (true) {
4960  llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4961 
4962  switch (Entry.Kind) {
4963  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4965  Error("malformed block record in AST file");
4966  return Failure;
4967  case llvm::BitstreamEntry::EndBlock:
4968  return Success;
4969  case llvm::BitstreamEntry::Record:
4970  // The interesting case.
4971  break;
4972  }
4973 
4974  // Read a record.
4975  StringRef Blob;
4976  Record.clear();
4977  auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4978 
4979  if ((Kind == SUBMODULE_METADATA) != First) {
4980  Error("submodule metadata record should be at beginning of block");
4981  return Failure;
4982  }
4983  First = false;
4984 
4985  // Submodule information is only valid if we have a current module.
4986  // FIXME: Should we error on these cases?
4987  if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4989  continue;
4990 
4991  switch (Kind) {
4992  default: // Default behavior: ignore.
4993  break;
4994 
4995  case SUBMODULE_DEFINITION: {
4996  if (Record.size() < 12) {
4997  Error("malformed module definition");
4998  return Failure;
4999  }
5000 
5001  StringRef Name = Blob;
5002  unsigned Idx = 0;
5003  SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5004  SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5005  Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5006  bool IsFramework = Record[Idx++];
5007  bool IsExplicit = Record[Idx++];
5008  bool IsSystem = Record[Idx++];
5009  bool IsExternC = Record[Idx++];
5010  bool InferSubmodules = Record[Idx++];
5011  bool InferExplicitSubmodules = Record[Idx++];
5012  bool InferExportWildcard = Record[Idx++];
5013  bool ConfigMacrosExhaustive = Record[Idx++];
5014  bool ModuleMapIsPrivate = Record[Idx++];
5015 
5016  Module *ParentModule = nullptr;
5017  if (Parent)
5018  ParentModule = getSubmodule(Parent);
5019 
5020  // Retrieve this (sub)module from the module map, creating it if
5021  // necessary.
5022  CurrentModule =
5023  ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5024  .first;
5025 
5026  // FIXME: set the definition loc for CurrentModule, or call
5027  // ModMap.setInferredModuleAllowedBy()
5028 
5029  SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5030  if (GlobalIndex >= SubmodulesLoaded.size() ||
5031  SubmodulesLoaded[GlobalIndex]) {
5032  Error("too many submodules");
5033  return Failure;
5034  }
5035 
5036  if (!ParentModule) {
5037  if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5038  // Don't emit module relocation error if we have -fno-validate-pch
5039  if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5040  CurFile != F.File) {
5041  if (!Diags.isDiagnosticInFlight()) {
5042  Diag(diag::err_module_file_conflict)
5043  << CurrentModule->getTopLevelModuleName()
5044  << CurFile->getName()
5045  << F.File->getName();
5046  }
5047  return Failure;
5048  }
5049  }
5050 
5051  CurrentModule->setASTFile(F.File);
5052  CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5053  }
5054 
5055  CurrentModule->Kind = Kind;
5056  CurrentModule->Signature = F.Signature;
5057  CurrentModule->IsFromModuleFile = true;
5058  CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5059  CurrentModule->IsExternC = IsExternC;
5060  CurrentModule->InferSubmodules = InferSubmodules;
5061  CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5062  CurrentModule->InferExportWildcard = InferExportWildcard;
5063  CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5064  CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5065  if (DeserializationListener)
5066  DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5067 
5068  SubmodulesLoaded[GlobalIndex] = CurrentModule;
5069 
5070  // Clear out data that will be replaced by what is in the module file.
5071  CurrentModule->LinkLibraries.clear();
5072  CurrentModule->ConfigMacros.clear();
5073  CurrentModule->UnresolvedConflicts.clear();
5074  CurrentModule->Conflicts.clear();
5075 
5076  // The module is available unless it's missing a requirement; relevant
5077  // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5078  // Missing headers that were present when the module was built do not
5079  // make it unavailable -- if we got this far, this must be an explicitly
5080  // imported module file.
5081  CurrentModule->Requirements.clear();
5082  CurrentModule->MissingHeaders.clear();
5083  CurrentModule->IsMissingRequirement =
5084  ParentModule && ParentModule->IsMissingRequirement;
5085  CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5086  break;
5087  }
5088 
5090  std::string Filename = Blob;
5091  ResolveImportedPath(F, Filename);
5092  if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5093  if (!CurrentModule->getUmbrellaHeader())
5094  ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5095  else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5096  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5097  Error("mismatched umbrella headers in submodule");
5098  return OutOfDate;
5099  }
5100  }
5101  break;
5102  }
5103 
5104  case SUBMODULE_HEADER:
5107  // We lazily associate headers with their modules via the HeaderInfo table.
5108  // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5109  // of complete filenames or remove it entirely.
5110  break;
5111 
5114  // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5115  // them here.
5116  break;
5117 
5118  case SUBMODULE_TOPHEADER:
5119  CurrentModule->addTopHeaderFilename(Blob);
5120  break;
5121 
5122  case SUBMODULE_UMBRELLA_DIR: {
5123  std::string Dirname = Blob;
5124  ResolveImportedPath(F, Dirname);
5125  if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5126  if (!CurrentModule->getUmbrellaDir())
5127  ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5128  else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5129  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5130  Error("mismatched umbrella directories in submodule");
5131  return OutOfDate;
5132  }
5133  }
5134  break;
5135  }
5136 
5137  case SUBMODULE_METADATA: {
5138  F.BaseSubmoduleID = getTotalNumSubmodules();
5139  F.LocalNumSubmodules = Record[0];
5140  unsigned LocalBaseSubmoduleID = Record[1];
5141  if (F.LocalNumSubmodules > 0) {
5142  // Introduce the global -> local mapping for submodules within this
5143  // module.
5144  GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5145 
5146  // Introduce the local -> global mapping for submodules within this
5147  // module.
5149  std::make_pair(LocalBaseSubmoduleID,
5150  F.BaseSubmoduleID - LocalBaseSubmoduleID));
5151 
5152  SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5153  }
5154  break;
5155  }
5156 
5157  case SUBMODULE_IMPORTS:
5158  for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5159  UnresolvedModuleRef Unresolved;
5160  Unresolved.File = &F;
5161  Unresolved.Mod = CurrentModule;
5162  Unresolved.ID = Record[Idx];
5163  Unresolved.Kind = UnresolvedModuleRef::Import;
5164  Unresolved.IsWildcard = false;
5165  UnresolvedModuleRefs.push_back(Unresolved);
5166  }
5167  break;
5168 
5169  case SUBMODULE_EXPORTS:
5170  for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5171  UnresolvedModuleRef Unresolved;
5172  Unresolved.File = &F;
5173  Unresolved.Mod = CurrentModule;
5174  Unresolved.ID = Record[Idx];
5175  Unresolved.Kind = UnresolvedModuleRef::Export;
5176  Unresolved.IsWildcard = Record[Idx + 1];
5177  UnresolvedModuleRefs.push_back(Unresolved);
5178  }
5179 
5180  // Once we've loaded the set of exports, there's no reason to keep
5181  // the parsed, unresolved exports around.
5182  CurrentModule->UnresolvedExports.clear();
5183  break;
5184 
5185  case SUBMODULE_REQUIRES:
5186  CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5187  PP.getTargetInfo());
5188  break;
5189 
5191  ModMap.resolveLinkAsDependencies(CurrentModule);
5192  CurrentModule->LinkLibraries.push_back(
5193  Module::LinkLibrary(Blob, Record[0]));
5194  break;
5195 
5197  CurrentModule->ConfigMacros.push_back(Blob.str());
5198  break;
5199 
5200  case SUBMODULE_CONFLICT: {
5201  UnresolvedModuleRef Unresolved;
5202  Unresolved.File = &F;
5203  Unresolved.Mod = CurrentModule;
5204  Unresolved.ID = Record[0];
5205  Unresolved.Kind = UnresolvedModuleRef::Conflict;
5206  Unresolved.IsWildcard = false;
5207  Unresolved.String = Blob;
5208  UnresolvedModuleRefs.push_back(Unresolved);
5209  break;
5210  }
5211 
5212  case SUBMODULE_INITIALIZERS: {
5213  if (!ContextObj)
5214  break;
5216  for (auto &ID : Record)
5217  Inits.push_back(getGlobalDeclID(F, ID));
5218  ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5219  break;
5220  }
5221 
5222  case SUBMODULE_EXPORT_AS:
5223  CurrentModule->ExportAsModule = Blob.str();
5224  ModMap.addLinkAsDependency(CurrentModule);
5225  break;
5226  }
5227  }
5228 }
5229 
5230 /// Parse the record that corresponds to a LangOptions data
5231 /// structure.
5232 ///
5233 /// This routine parses the language options from the AST file and then gives
5234 /// them to the AST listener if one is set.
5235 ///
5236 /// \returns true if the listener deems the file unacceptable, false otherwise.
5237 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5238  bool Complain,
5239  ASTReaderListener &Listener,
5240  bool AllowCompatibleDifferences) {
5241  LangOptions LangOpts;
5242  unsigned Idx = 0;
5243 #define LANGOPT(Name, Bits, Default, Description) \
5244  LangOpts.Name = Record[Idx++];
5245 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5246  LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5247 #include "clang/Basic/LangOptions.def"
5248 #define SANITIZER(NAME, ID) \
5249  LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5250 #include "clang/Basic/Sanitizers.def"
5251 
5252  for (unsigned N = Record[Idx++]; N; --N)
5253  LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5254 
5255  ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5256  VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5257  LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5258 
5259  LangOpts.CurrentModule = ReadString(Record, Idx);
5260 
5261  // Comment options.
5262  for (unsigned N = Record[Idx++]; N; --N) {
5263  LangOpts.CommentOpts.BlockCommandNames.push_back(
5264  ReadString(Record, Idx));
5265  }
5266  LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5267 
5268  // OpenMP offloading options.
5269  for (unsigned N = Record[Idx++]; N; --N) {
5270  LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5271  }
5272 
5273  LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5274 
5275  return Listener.ReadLanguageOptions(LangOpts, Complain,
5276  AllowCompatibleDifferences);
5277 }
5278 
5279 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5280  ASTReaderListener &Listener,
5281  bool AllowCompatibleDifferences) {
5282  unsigned Idx = 0;
5283  TargetOptions TargetOpts;
5284  TargetOpts.Triple = ReadString(Record, Idx);
5285  TargetOpts.CPU = ReadString(Record, Idx);
5286  TargetOpts.ABI = ReadString(Record, Idx);
5287  for (unsigned N = Record[Idx++]; N; --N) {
5288  TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5289  }
5290  for (unsigned N = Record[Idx++]; N; --N) {
5291  TargetOpts.Features.push_back(ReadString(Record, Idx));
5292  }
5293 
5294  return Listener.ReadTargetOptions(TargetOpts, Complain,
5295  AllowCompatibleDifferences);
5296 }
5297 
5298 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5299  ASTReaderListener &Listener) {
5301  unsigned Idx = 0;
5302 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5303 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5304  DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5305 #include "clang/Basic/DiagnosticOptions.def"
5306 
5307  for (unsigned N = Record[Idx++]; N; --N)
5308  DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5309  for (unsigned N = Record[Idx++]; N; --N)
5310  DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5311 
5312  return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5313 }
5314 
5315 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5316  ASTReaderListener &Listener) {
5317  FileSystemOptions FSOpts;
5318  unsigned Idx = 0;
5319  FSOpts.WorkingDir = ReadString(Record, Idx);
5320  return Listener.ReadFileSystemOptions(FSOpts, Complain);
5321 }
5322 
5323 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5324  bool Complain,
5325  ASTReaderListener &Listener) {
5326  HeaderSearchOptions HSOpts;
5327  unsigned Idx = 0;
5328  HSOpts.Sysroot = ReadString(Record, Idx);
5329 
5330  // Include entries.
5331  for (unsigned N = Record[Idx++]; N; --N) {
5332  std::string Path = ReadString(Record, Idx);
5334  = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5335  bool IsFramework = Record[Idx++];
5336  bool IgnoreSysRoot = Record[Idx++];
5337  HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5338  IgnoreSysRoot);
5339  }
5340 
5341  // System header prefixes.
5342  for (unsigned N = Record[Idx++]; N; --N) {
5343  std::string Prefix = ReadString(Record, Idx);
5344  bool IsSystemHeader = Record[Idx++];
5345  HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5346  }
5347 
5348  HSOpts.ResourceDir = ReadString(Record, Idx);
5349  HSOpts.ModuleCachePath = ReadString(Record, Idx);
5350  HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5351  HSOpts.DisableModuleHash = Record[Idx++];
5352  HSOpts.ImplicitModuleMaps = Record[Idx++];
5353  HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5354  HSOpts.UseBuiltinIncludes = Record[Idx++];
5355  HSOpts.UseStandardSystemIncludes = Record[Idx++];
5356  HSOpts.UseStandardCXXIncludes = Record[Idx++];
5357  HSOpts.UseLibcxx = Record[Idx++];
5358  std::string SpecificModuleCachePath = ReadString(Record, Idx);
5359 
5360  return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5361  Complain);
5362 }
5363 
5364 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5365  bool Complain,
5366  ASTReaderListener &Listener,
5367  std::string &SuggestedPredefines) {
5368  PreprocessorOptions PPOpts;
5369  unsigned Idx = 0;
5370 
5371  // Macro definitions/undefs
5372  for (unsigned N = Record[Idx++]; N; --N) {
5373  std::string Macro = ReadString(Record, Idx);
5374  bool IsUndef = Record[Idx++];
5375  PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5376  }
5377 
5378  // Includes
5379  for (unsigned N = Record[Idx++]; N; --N) {
5380  PPOpts.Includes.push_back(ReadString(Record, Idx));
5381  }
5382 
5383  // Macro Includes
5384  for (unsigned N = Record[Idx++]; N; --N) {
5385  PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5386  }
5387 
5388  PPOpts.UsePredefines = Record[Idx++];
5389  PPOpts.DetailedRecord = Record[Idx++];
5390  PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5391  PPOpts.ObjCXXARCStandardLibrary =
5392  static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5393  SuggestedPredefines.clear();
5394  return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5395  SuggestedPredefines);
5396 }
5397 
5398 std::pair<ModuleFile *, unsigned>
5399 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5401  I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5402  assert(I != GlobalPreprocessedEntityMap.end() &&
5403  "Corrupted global preprocessed entity map");
5404  ModuleFile *M = I->second;
5405  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5406  return std::make_pair(M, LocalIndex);
5407 }
5408 
5409 llvm::iterator_range<PreprocessingRecord::iterator>
5410 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5411  if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5412  return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5414 
5415  return llvm::make_range(PreprocessingRecord::iterator(),
5417 }
5418 
5419 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5421  return llvm::make_range(
5422  ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5423  ModuleDeclIterator(this, &Mod,
5424  Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5425 }
5426 
5428  auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5429  assert(I != GlobalSkippedRangeMap.end() &&
5430  "Corrupted global skipped range map");
5431  ModuleFile *M = I->second;
5432  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5433  assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5434  PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5435  SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5436  TranslateSourceLocation(*M, RawRange.getEnd()));
5437  assert(Range.isValid());
5438  return Range;
5439 }
5440 
5442  PreprocessedEntityID PPID = Index+1;
5443  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5444  ModuleFile &M = *PPInfo.first;
5445  unsigned LocalIndex = PPInfo.second;
5446  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5447 
5448  if (!PP.getPreprocessingRecord()) {
5449  Error("no preprocessing record");
5450  return nullptr;
5451  }
5452 
5454  M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5455 
5456  llvm::BitstreamEntry Entry =
5457  M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5458  if (Entry.Kind != llvm::BitstreamEntry::Record)
5459  return nullptr;
5460 
5461  // Read the record.
5462  SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5463  TranslateSourceLocation(M, PPOffs.getEnd()));
5464  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5465  StringRef Blob;
5466  RecordData Record;
5469  Entry.ID, Record, &Blob);
5470  switch (RecType) {
5471  case PPD_MACRO_EXPANSION: {
5472  bool isBuiltin = Record[0];
5473  IdentifierInfo *Name = nullptr;
5474  MacroDefinitionRecord *Def = nullptr;
5475  if (isBuiltin)
5476  Name = getLocalIdentifier(M, Record[1]);
5477  else {
5478  PreprocessedEntityID GlobalID =
5479  getGlobalPreprocessedEntityID(M, Record[1]);
5480  Def = cast<MacroDefinitionRecord>(
5481  PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5482  }
5483 
5484  MacroExpansion *ME;
5485  if (isBuiltin)
5486  ME = new (PPRec) MacroExpansion(Name, Range);
5487  else
5488  ME = new (PPRec) MacroExpansion(Def, Range);
5489 
5490  return ME;
5491  }
5492 
5493  case PPD_MACRO_DEFINITION: {
5494  // Decode the identifier info and then check again; if the macro is
5495  // still defined and associated with the identifier,
5496  IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5497  MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5498 
5499  if (DeserializationListener)
5500  DeserializationListener->MacroDefinitionRead(PPID, MD);
5501 
5502  return MD;
5503  }
5504 
5505  case PPD_INCLUSION_DIRECTIVE: {
5506  const char *FullFileNameStart = Blob.data() + Record[0];
5507  StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5508  const FileEntry *File = nullptr;
5509  if (!FullFileName.empty())
5510  File = PP.getFileManager().getFile(FullFileName);
5511 
5512  // FIXME: Stable encoding
5514  = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5516  = new (PPRec) InclusionDirective(PPRec, Kind,
5517  StringRef(Blob.data(), Record[0]),
5518  Record[1], Record[3],
5519  File,
5520  Range);
5521  return ID;
5522  }
5523  }
5524 
5525  llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5526 }
5527 
5528 /// Find the next module that contains entities and return the ID
5529 /// of the first entry.
5530 ///
5531 /// \param SLocMapI points at a chunk of a module that contains no
5532 /// preprocessed entities or the entities it contains are not the ones we are
5533 /// looking for.
5534 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5535  GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5536  ++SLocMapI;
5538  EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5539  ModuleFile &M = *SLocMapI->second;
5541  return M.BasePreprocessedEntityID;
5542  }
5543 
5544  return getTotalNumPreprocessedEntities();
5545 }
5546 
5547 namespace {
5548 
5549 struct PPEntityComp {
5550  const ASTReader &Reader;
5551  ModuleFile &M;
5552 
5553  PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5554 
5555  bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5556  SourceLocation LHS = getLoc(L);
5557  SourceLocation RHS = getLoc(R);
5558  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5559  }
5560 
5561  bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5562  SourceLocation LHS = getLoc(L);
5563  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5564  }
5565 
5566  bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5567  SourceLocation RHS = getLoc(R);
5568  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5569  }
5570 
5571  SourceLocation getLoc(const PPEntityOffset &PPE) const {
5572  return Reader.TranslateSourceLocation(M, PPE.getBegin());
5573  }
5574 };
5575 
5576 } // namespace
5577 
5578 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5579  bool EndsAfter) const {
5580  if (SourceMgr.isLocalSourceLocation(Loc))
5581  return getTotalNumPreprocessedEntities();
5582 
5583  GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5584  SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5585  assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5586  "Corrupted global sloc offset map");
5587 
5588  if (SLocMapI->second->NumPreprocessedEntities == 0)
5589  return findNextPreprocessedEntity(SLocMapI);
5590 
5591  ModuleFile &M = *SLocMapI->second;
5592 
5593  using pp_iterator = const PPEntityOffset *;
5594 
5595  pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5596  pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5597 
5598  size_t Count = M.NumPreprocessedEntities;
5599  size_t Half;
5600  pp_iterator First = pp_begin;
5601  pp_iterator PPI;
5602 
5603  if (EndsAfter) {
5604  PPI = std::upper_bound(pp_begin, pp_end, Loc,
5605  PPEntityComp(*this, M));
5606  } else {
5607  // Do a binary search manually instead of using std::lower_bound because
5608  // The end locations of entities may be unordered (when a macro expansion
5609  // is inside another macro argument), but for this case it is not important
5610  // whether we get the first macro expansion or its containing macro.
5611  while (Count > 0) {
5612  Half = Count / 2;
5613  PPI = First;
5614  std::advance(PPI, Half);
5615  if (SourceMgr.isBeforeInTranslationUnit(
5616  TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5617  First = PPI;
5618  ++First;
5619  Count = Count - Half - 1;
5620  } else
5621  Count = Half;
5622  }
5623  }
5624 
5625  if (PPI == pp_end)
5626  return findNextPreprocessedEntity(SLocMapI);
5627 
5628  return M.BasePreprocessedEntityID + (PPI - pp_begin);
5629 }
5630 
5631 /// Returns a pair of [Begin, End) indices of preallocated
5632 /// preprocessed entities that \arg Range encompasses.
5633 std::pair<unsigned, unsigned>
5635  if (Range.isInvalid())
5636  return std::make_pair(0,0);
5637  assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5638 
5639  PreprocessedEntityID BeginID =
5640  findPreprocessedEntity(Range.getBegin(), false);
5641  PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5642  return std::make_pair(BeginID, EndID);
5643 }
5644 
5645 /// Optionally returns true or false if the preallocated preprocessed
5646 /// entity with index \arg Index came from file \arg FID.
5648  FileID FID) {
5649  if (FID.isInvalid())
5650  return false;
5651 
5652  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5653  ModuleFile &M = *PPInfo.first;
5654  unsigned LocalIndex = PPInfo.second;
5655  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5656 
5657  SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5658  if (Loc.isInvalid())
5659  return false;
5660 
5661  if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5662  return true;
5663  else
5664  return false;
5665 }
5666 
5667 namespace {
5668 
5669  /// Visitor used to search for information about a header file.
5670  class HeaderFileInfoVisitor {
5671  const FileEntry *FE;
5673 
5674  public:
5675  explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5676 
5677  bool operator()(ModuleFile &M) {
5679  = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5680  if (!Table)
5681  return false;
5682 
5683  // Look in the on-disk hash table for an entry for this file name.
5684  HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5685  if (Pos == Table->end())
5686  return false;
5687 
5688  HFI = *Pos;
5689  return true;
5690  }
5691 
5692  Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5693  };
5694 
5695 } // namespace
5696 
5698  HeaderFileInfoVisitor Visitor(FE);
5699  ModuleMgr.visit(Visitor);
5700  if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5701  return *HFI;
5702 
5703  return HeaderFileInfo();
5704 }
5705 
5707  using DiagState = DiagnosticsEngine::DiagState;
5708  SmallVector<DiagState *, 32> DiagStates;
5709 
5710  for (ModuleFile &F : ModuleMgr) {
5711  unsigned Idx = 0;
5712  auto &Record = F.PragmaDiagMappings;
5713  if (Record.empty())
5714  continue;
5715 
5716  DiagStates.clear();
5717 
5718  auto ReadDiagState =
5719  [&](const DiagState &BasedOn, SourceLocation Loc,
5720  bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5721  unsigned BackrefID = Record[Idx++];
5722  if (BackrefID != 0)
5723  return DiagStates[BackrefID - 1];
5724 
5725  // A new DiagState was created here.
5726  Diag.DiagStates.push_back(BasedOn);
5727  DiagState *NewState = &Diag.DiagStates.back();
5728  DiagStates.push_back(NewState);
5729  unsigned Size = Record[Idx++];
5730  assert(Idx + Size * 2 <= Record.size() &&
5731  "Invalid data, not enough diag/map pairs");
5732  while (Size--) {
5733  unsigned DiagID = Record[Idx++];
5734  DiagnosticMapping NewMapping =
5735  DiagnosticMapping::deserialize(Record[Idx++]);
5736  if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5737  continue;
5738 
5739  DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5740 
5741  // If this mapping was specified as a warning but the severity was
5742  // upgraded due to diagnostic settings, simulate the current diagnostic
5743  // settings (and use a warning).
5744  if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5746  NewMapping.setUpgradedFromWarning(false);
5747  }
5748 
5749  Mapping = NewMapping;
5750  }
5751  return NewState;
5752  };
5753 
5754  // Read the first state.
5755  DiagState *FirstState;
5756  if (F.Kind == MK_ImplicitModule) {
5757  // Implicitly-built modules are reused with different diagnostic
5758  // settings. Use the initial diagnostic state from Diag to simulate this
5759  // compilation's diagnostic settings.
5760  FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5761  DiagStates.push_back(FirstState);
5762 
5763  // Skip the initial diagnostic state from the serialized module.
5764  assert(Record[1] == 0 &&
5765  "Invalid data, unexpected backref in initial state");
5766  Idx = 3 + Record[2] * 2;
5767  assert(Idx < Record.size() &&
5768  "Invalid data, not enough state change pairs in initial state");
5769  } else if (F.isModule()) {
5770  // For an explicit module, preserve the flags from the module build
5771  // command line (-w, -Weverything, -Werror, ...) along with any explicit
5772  // -Wblah flags.
5773  unsigned Flags = Record[Idx++];
5774  DiagState Initial;
5775  Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5776  Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5777  Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5778  Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5779  Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5780  Initial.ExtBehavior = (diag::Severity)Flags;
5781  FirstState = ReadDiagState(Initial, SourceLocation(), true);
5782 
5783  assert(F.OriginalSourceFileID.isValid());
5784 
5785  // Set up the root buffer of the module to start with the initial
5786  // diagnostic state of the module itself, to cover files that contain no
5787  // explicit transitions (for which we did not serialize anything).
5788  Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5789  .StateTransitions.push_back({FirstState, 0});
5790  } else {
5791  // For prefix ASTs, start with whatever the user configured on the
5792  // command line.
5793  Idx++; // Skip flags.
5794  FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5795  SourceLocation(), false);
5796  }
5797 
5798  // Read the state transitions.
5799  unsigned NumLocations = Record[Idx++];
5800  while (NumLocations--) {
5801  assert(Idx < Record.size() &&
5802  "Invalid data, missing pragma diagnostic states");
5803  SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5804  auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5805  assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
5806  assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5807  unsigned Transitions = Record[Idx++];
5808 
5809  // Note that we don't need to set up Parent/ParentOffset here, because
5810  // we won't be changing the diagnostic state within imported FileIDs
5811  // (other than perhaps appending to the main source file, which has no
5812  // parent).
5813  auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5814  F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5815  for (unsigned I = 0; I != Transitions; ++I) {
5816  unsigned Offset = Record[Idx++];
5817  auto *State =
5818  ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5819  F.StateTransitions.push_back({State, Offset});
5820  }
5821  }
5822 
5823  // Read the final state.
5824  assert(Idx < Record.size() &&
5825  "Invalid data, missing final pragma diagnostic state");
5826  SourceLocation CurStateLoc =
5827  ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5828  auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5829 
5830  if (!F.isModule()) {
5831  Diag.DiagStatesByLoc.CurDiagState = CurState;
5832  Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5833 
5834  // Preserve the property that the imaginary root file describes the
5835  // current state.
5836  FileID NullFile;
5837  auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5838  if (T.empty())
5839  T.push_back({CurState, 0});
5840  else
5841  T[0].State = CurState;
5842  }
5843 
5844  // Don't try to read these mappings again.
5845  Record.clear();
5846  }
5847 }
5848 
5849 /// Get the correct cursor and offset for loading a type.
5850 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5851  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5852  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5853  ModuleFile *M = I->second;
5854  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5855 }
5856 
5857 /// Read and return the type with the given index..
5858 ///
5859 /// The index is the type ID, shifted and minus the number of predefs. This
5860 /// routine actually reads the record corresponding to the type at the given
5861 /// location. It is a helper routine for GetType, which deals with reading type
5862 /// IDs.
5863 QualType ASTReader::readTypeRecord(unsigned Index) {
5864  assert(ContextObj && "reading type with no AST context");
5865  ASTContext &Context = *ContextObj;
5866  RecordLocation Loc = TypeCursorForIndex(Index);
5867  BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5868 
5869  // Keep track of where we are in the stream, then jump back there
5870  // after reading this type.
5871  SavedStreamPosition SavedPosition(DeclsCursor);
5872 
5873  ReadingKindTracker ReadingKind(Read_Type, *this);
5874 
5875  // Note that we are loading a type record.
5876  Deserializing AType(this);
5877 
5878  unsigned Idx = 0;
5879  DeclsCursor.JumpToBit(Loc.Offset);
5880  RecordData Record;
5881  unsigned Code = DeclsCursor.ReadCode();
5882  switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5883  case TYPE_EXT_QUAL: {
5884  if (Record.size() != 2) {
5885  Error("Incorrect encoding of extended qualifier type");
5886  return QualType();
5887  }
5888  QualType Base = readType(*Loc.F, Record, Idx);
5889  Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5890  return Context.getQualifiedType(Base, Quals);
5891  }
5892 
5893  case TYPE_COMPLEX: {
5894  if (Record.size() != 1) {
5895  Error("Incorrect encoding of complex type");
5896  return QualType();
5897  }
5898  QualType ElemType = readType(*Loc.F, Record, Idx);
5899  return Context.getComplexType(ElemType);
5900  }
5901 
5902  case TYPE_POINTER: {
5903  if (Record.size() != 1) {
5904  Error("Incorrect encoding of pointer type");
5905  return QualType();
5906  }
5907  QualType PointeeType = readType(*Loc.F, Record, Idx);
5908  return Context.getPointerType(PointeeType);
5909  }
5910 
5911  case TYPE_DECAYED: {
5912  if (Record.size() != 1) {
5913  Error("Incorrect encoding of decayed type");
5914  return QualType();
5915  }
5916  QualType OriginalType = readType(*Loc.F, Record, Idx);
5917  QualType DT = Context.getAdjustedParameterType(OriginalType);
5918  if (!isa<DecayedType>(DT))
5919  Error("Decayed type does not decay");
5920  return DT;
5921  }
5922 
5923  case TYPE_ADJUSTED: {
5924  if (Record.size() != 2) {
5925  Error("Incorrect encoding of adjusted type");
5926  return QualType();
5927  }
5928  QualType OriginalTy = readType(*Loc.F, Record, Idx);
5929  QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5930  return Context.getAdjustedType(OriginalTy, AdjustedTy);
5931  }
5932 
5933  case TYPE_BLOCK_POINTER: {
5934  if (Record.size() != 1) {
5935  Error("Incorrect encoding of block pointer type");
5936  return QualType();
5937  }
5938  QualType PointeeType = readType(*Loc.F, Record, Idx);
5939  return Context.getBlockPointerType(PointeeType);
5940  }
5941 
5942  case TYPE_LVALUE_REFERENCE: {
5943  if (Record.size() != 2) {
5944  Error("Incorrect encoding of lvalue reference type");
5945  return QualType();
5946  }
5947  QualType PointeeType = readType(*Loc.F, Record, Idx);
5948  return Context.getLValueReferenceType(PointeeType, Record[1]);
5949  }
5950 
5951  case TYPE_RVALUE_REFERENCE: {
5952  if (Record.size() != 1) {
5953  Error("Incorrect encoding of rvalue reference type");
5954  return QualType();
5955  }
5956  QualType PointeeType = readType(*Loc.F, Record, Idx);
5957  return Context.getRValueReferenceType(PointeeType);
5958  }
5959 
5960  case TYPE_MEMBER_POINTER: {
5961  if (Record.size() != 2) {
5962  Error("Incorrect encoding of member pointer type");
5963  return QualType();
5964  }
5965  QualType PointeeType = readType(*Loc.F, Record, Idx);
5966  QualType ClassType = readType(*Loc.F, Record, Idx);
5967  if (PointeeType.isNull() || ClassType.isNull())
5968  return QualType();
5969 
5970  return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5971  }
5972 
5973  case TYPE_CONSTANT_ARRAY: {
5974  QualType ElementType = readType(*Loc.F, Record, Idx);
5976  unsigned IndexTypeQuals = Record[2];
5977  unsigned Idx = 3;
5978  llvm::APInt Size = ReadAPInt(Record, Idx);
5979  return Context.getConstantArrayType(ElementType, Size,
5980  ASM, IndexTypeQuals);
5981  }
5982 
5983  case TYPE_INCOMPLETE_ARRAY: {
5984  QualType ElementType = readType(*Loc.F, Record, Idx);
5986  unsigned IndexTypeQuals = Record[2];
5987  return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5988  }
5989 
5990  case TYPE_VARIABLE_ARRAY: {
5991  QualType ElementType = readType(*Loc.F, Record, Idx);
5993  unsigned IndexTypeQuals = Record[2];
5994  SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5995  SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5996  return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5997  ASM, IndexTypeQuals,
5998  SourceRange(LBLoc, RBLoc));
5999  }
6000 
6001  case TYPE_VECTOR: {
6002  if (Record.size() != 3) {
6003  Error("incorrect encoding of vector type in AST file");
6004  return QualType();
6005  }
6006 
6007  QualType ElementType = readType(*Loc.F, Record, Idx);
6008  unsigned NumElements = Record[1];
6009  unsigned VecKind = Record[2];
6010  return Context.getVectorType(ElementType, NumElements,
6011  (VectorType::VectorKind)VecKind);
6012  }
6013 
6014  case TYPE_EXT_VECTOR: {
6015  if (Record.size() != 3) {
6016  Error("incorrect encoding of extended vector type in AST file");
6017  return QualType();
6018  }
6019 
6020  QualType ElementType = readType(*Loc.F, Record, Idx);
6021  unsigned NumElements = Record[1];
6022  return Context.getExtVectorType(ElementType, NumElements);
6023  }
6024 
6025  case TYPE_FUNCTION_NO_PROTO: {
6026  if (Record.size() != 8) {
6027  Error("incorrect encoding of no-proto function type");
6028  return QualType();
6029  }
6030  QualType ResultType = readType(*Loc.F, Record, Idx);
6031  FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
6032  (CallingConv)Record[4], Record[5], Record[6],
6033