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