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