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