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