clang  5.0.0
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/DeclCXX.h"
23 #include "clang/AST/DeclGroup.h"
24 #include "clang/AST/DeclObjC.h"
25 #include "clang/AST/DeclTemplate.h"
26 #include "clang/AST/Expr.h"
27 #include "clang/AST/ExprCXX.h"
29 #include "clang/AST/ODRHash.h"
31 #include "clang/AST/Type.h"
43 #include "clang/Basic/Sanitizers.h"
46 #include "clang/Basic/Specifiers.h"
47 #include "clang/Basic/TargetInfo.h"
49 #include "clang/Basic/TokenKinds.h"
50 #include "clang/Basic/Version.h"
53 #include "clang/Lex/HeaderSearch.h"
55 #include "clang/Lex/MacroInfo.h"
56 #include "clang/Lex/ModuleMap.h"
58 #include "clang/Lex/Preprocessor.h"
60 #include "clang/Sema/Scope.h"
61 #include "clang/Sema/Sema.h"
62 #include "clang/Sema/Weak.h"
67 #include "llvm/ADT/APFloat.h"
68 #include "llvm/ADT/APInt.h"
69 #include "llvm/ADT/APSInt.h"
70 #include "llvm/ADT/Hashing.h"
71 #include "llvm/ADT/SmallString.h"
72 #include "llvm/ADT/StringExtras.h"
73 #include "llvm/ADT/Triple.h"
74 #include "llvm/Bitcode/BitstreamReader.h"
75 #include "llvm/Support/Compression.h"
76 #include "llvm/Support/Compiler.h"
77 #include "llvm/Support/Error.h"
78 #include "llvm/Support/ErrorHandling.h"
79 #include "llvm/Support/FileSystem.h"
80 #include "llvm/Support/MemoryBuffer.h"
81 #include "llvm/Support/Path.h"
82 #include "llvm/Support/SaveAndRestore.h"
83 #include "llvm/Support/raw_ostream.h"
84 #include <algorithm>
85 #include <cassert>
86 #include <cstdint>
87 #include <cstdio>
88 #include <cstring>
89 #include <ctime>
90 #include <iterator>
91 #include <limits>
92 #include <map>
93 #include <memory>
94 #include <new>
95 #include <string>
96 #include <system_error>
97 #include <tuple>
98 #include <utility>
99 #include <vector>
100 
101 using namespace clang;
102 using namespace clang::serialization;
103 using namespace clang::serialization::reader;
104 using llvm::BitstreamCursor;
105 
106 //===----------------------------------------------------------------------===//
107 // ChainedASTReaderListener implementation
108 //===----------------------------------------------------------------------===//
109 
110 bool
112  return First->ReadFullVersionInformation(FullVersion) ||
113  Second->ReadFullVersionInformation(FullVersion);
114 }
115 
116 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
117  First->ReadModuleName(ModuleName);
118  Second->ReadModuleName(ModuleName);
119 }
120 
121 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
122  First->ReadModuleMapFile(ModuleMapPath);
123  Second->ReadModuleMapFile(ModuleMapPath);
124 }
125 
126 bool
128  bool Complain,
129  bool AllowCompatibleDifferences) {
130  return First->ReadLanguageOptions(LangOpts, Complain,
131  AllowCompatibleDifferences) ||
132  Second->ReadLanguageOptions(LangOpts, Complain,
133  AllowCompatibleDifferences);
134 }
135 
137  const TargetOptions &TargetOpts, bool Complain,
138  bool AllowCompatibleDifferences) {
139  return First->ReadTargetOptions(TargetOpts, Complain,
140  AllowCompatibleDifferences) ||
141  Second->ReadTargetOptions(TargetOpts, Complain,
142  AllowCompatibleDifferences);
143 }
144 
146  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
147  return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
148  Second->ReadDiagnosticOptions(DiagOpts, Complain);
149 }
150 
151 bool
153  bool Complain) {
154  return First->ReadFileSystemOptions(FSOpts, Complain) ||
155  Second->ReadFileSystemOptions(FSOpts, Complain);
156 }
157 
159  const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
160  bool Complain) {
161  return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
162  Complain) ||
163  Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
164  Complain);
165 }
166 
168  const PreprocessorOptions &PPOpts, bool Complain,
169  std::string &SuggestedPredefines) {
170  return First->ReadPreprocessorOptions(PPOpts, Complain,
171  SuggestedPredefines) ||
172  Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
173 }
175  unsigned Value) {
176  First->ReadCounter(M, Value);
177  Second->ReadCounter(M, Value);
178 }
180  return First->needsInputFileVisitation() ||
181  Second->needsInputFileVisitation();
182 }
184  return First->needsSystemInputFileVisitation() ||
185  Second->needsSystemInputFileVisitation();
186 }
188  ModuleKind Kind) {
189  First->visitModuleFile(Filename, Kind);
190  Second->visitModuleFile(Filename, Kind);
191 }
192 
194  bool isSystem,
195  bool isOverridden,
196  bool isExplicitModule) {
197  bool Continue = false;
198  if (First->needsInputFileVisitation() &&
199  (!isSystem || First->needsSystemInputFileVisitation()))
200  Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
201  isExplicitModule);
202  if (Second->needsInputFileVisitation() &&
203  (!isSystem || Second->needsSystemInputFileVisitation()))
204  Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
205  isExplicitModule);
206  return Continue;
207 }
208 
210  const ModuleFileExtensionMetadata &Metadata) {
211  First->readModuleFileExtension(Metadata);
212  Second->readModuleFileExtension(Metadata);
213 }
214 
215 //===----------------------------------------------------------------------===//
216 // PCH validator implementation
217 //===----------------------------------------------------------------------===//
218 
220 
221 /// \brief Compare the given set of language options against an existing set of
222 /// language options.
223 ///
224 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
225 /// \param AllowCompatibleDifferences If true, differences between compatible
226 /// language options will be permitted.
227 ///
228 /// \returns true if the languagae options mis-match, false otherwise.
229 static bool checkLanguageOptions(const LangOptions &LangOpts,
230  const LangOptions &ExistingLangOpts,
231  DiagnosticsEngine *Diags,
232  bool AllowCompatibleDifferences = true) {
233 #define LANGOPT(Name, Bits, Default, Description) \
234  if (ExistingLangOpts.Name != LangOpts.Name) { \
235  if (Diags) \
236  Diags->Report(diag::err_pch_langopt_mismatch) \
237  << Description << LangOpts.Name << ExistingLangOpts.Name; \
238  return true; \
239  }
240 
241 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
242  if (ExistingLangOpts.Name != LangOpts.Name) { \
243  if (Diags) \
244  Diags->Report(diag::err_pch_langopt_value_mismatch) \
245  << Description; \
246  return true; \
247  }
248 
249 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
250  if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
251  if (Diags) \
252  Diags->Report(diag::err_pch_langopt_value_mismatch) \
253  << Description; \
254  return true; \
255  }
256 
257 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
258  if (!AllowCompatibleDifferences) \
259  LANGOPT(Name, Bits, Default, Description)
260 
261 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
262  if (!AllowCompatibleDifferences) \
263  ENUM_LANGOPT(Name, Bits, Default, Description)
264 
265 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
266  if (!AllowCompatibleDifferences) \
267  VALUE_LANGOPT(Name, Bits, Default, Description)
268 
269 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
270 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
271 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
272 #include "clang/Basic/LangOptions.def"
273 
274  if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
275  if (Diags)
276  Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
277  return true;
278  }
279 
280  if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
281  if (Diags)
282  Diags->Report(diag::err_pch_langopt_value_mismatch)
283  << "target Objective-C runtime";
284  return true;
285  }
286 
287  if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
288  LangOpts.CommentOpts.BlockCommandNames) {
289  if (Diags)
290  Diags->Report(diag::err_pch_langopt_value_mismatch)
291  << "block command names";
292  return true;
293  }
294 
295  // Sanitizer feature mismatches are treated as compatible differences. If
296  // compatible differences aren't allowed, we still only want to check for
297  // mismatches of non-modular sanitizers (the only ones which can affect AST
298  // generation).
299  if (!AllowCompatibleDifferences) {
300  SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
301  SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
302  SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
303  ExistingSanitizers.clear(ModularSanitizers);
304  ImportedSanitizers.clear(ModularSanitizers);
305  if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
306  const std::string Flag = "-fsanitize=";
307  if (Diags) {
308 #define SANITIZER(NAME, ID) \
309  { \
310  bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
311  bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
312  if (InExistingModule != InImportedModule) \
313  Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
314  << InExistingModule << (Flag + NAME); \
315  }
316 #include "clang/Basic/Sanitizers.def"
317  }
318  return true;
319  }
320  }
321 
322  return false;
323 }
324 
325 /// \brief Compare the given set of target options against an existing set of
326 /// target options.
327 ///
328 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
329 ///
330 /// \returns true if the target options mis-match, false otherwise.
331 static bool checkTargetOptions(const TargetOptions &TargetOpts,
332  const TargetOptions &ExistingTargetOpts,
333  DiagnosticsEngine *Diags,
334  bool AllowCompatibleDifferences = true) {
335 #define CHECK_TARGET_OPT(Field, Name) \
336  if (TargetOpts.Field != ExistingTargetOpts.Field) { \
337  if (Diags) \
338  Diags->Report(diag::err_pch_targetopt_mismatch) \
339  << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
340  return true; \
341  }
342 
343  // The triple and ABI must match exactly.
344  CHECK_TARGET_OPT(Triple, "target");
345  CHECK_TARGET_OPT(ABI, "target ABI");
346 
347  // We can tolerate different CPUs in many cases, notably when one CPU
348  // supports a strict superset of another. When allowing compatible
349  // differences skip this check.
350  if (!AllowCompatibleDifferences)
351  CHECK_TARGET_OPT(CPU, "target CPU");
352 
353 #undef CHECK_TARGET_OPT
354 
355  // Compare feature sets.
356  SmallVector<StringRef, 4> ExistingFeatures(
357  ExistingTargetOpts.FeaturesAsWritten.begin(),
358  ExistingTargetOpts.FeaturesAsWritten.end());
359  SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
360  TargetOpts.FeaturesAsWritten.end());
361  std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
362  std::sort(ReadFeatures.begin(), ReadFeatures.end());
363 
364  // We compute the set difference in both directions explicitly so that we can
365  // diagnose the differences differently.
366  SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
367  std::set_difference(
368  ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
369  ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
370  std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
371  ExistingFeatures.begin(), ExistingFeatures.end(),
372  std::back_inserter(UnmatchedReadFeatures));
373 
374  // If we are allowing compatible differences and the read feature set is
375  // a strict subset of the existing feature set, there is nothing to diagnose.
376  if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
377  return false;
378 
379  if (Diags) {
380  for (StringRef Feature : UnmatchedReadFeatures)
381  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
382  << /* is-existing-feature */ false << Feature;
383  for (StringRef Feature : UnmatchedExistingFeatures)
384  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
385  << /* is-existing-feature */ true << Feature;
386  }
387 
388  return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
389 }
390 
391 bool
393  bool Complain,
394  bool AllowCompatibleDifferences) {
395  const LangOptions &ExistingLangOpts = PP.getLangOpts();
396  return checkLanguageOptions(LangOpts, ExistingLangOpts,
397  Complain ? &Reader.Diags : nullptr,
398  AllowCompatibleDifferences);
399 }
400 
402  bool Complain,
403  bool AllowCompatibleDifferences) {
404  const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
405  return checkTargetOptions(TargetOpts, ExistingTargetOpts,
406  Complain ? &Reader.Diags : nullptr,
407  AllowCompatibleDifferences);
408 }
409 
410 namespace {
411 
412  typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
413  MacroDefinitionsMap;
414  typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
415  DeclsMap;
416 
417 } // end anonymous namespace
418 
420  DiagnosticsEngine &Diags,
421  bool Complain) {
423 
424  // Check current mappings for new -Werror mappings, and the stored mappings
425  // for cases that were explicitly mapped to *not* be errors that are now
426  // errors because of options like -Werror.
427  DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
428 
429  for (DiagnosticsEngine *MappingSource : MappingSources) {
430  for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
431  diag::kind DiagID = DiagIDMappingPair.first;
432  Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
433  if (CurLevel < DiagnosticsEngine::Error)
434  continue; // not significant
435  Level StoredLevel =
436  StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
437  if (StoredLevel < DiagnosticsEngine::Error) {
438  if (Complain)
439  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
440  Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
441  return true;
442  }
443  }
444  }
445 
446  return false;
447 }
448 
451  if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
452  return true;
453  return Ext >= diag::Severity::Error;
454 }
455 
457  DiagnosticsEngine &Diags,
458  bool IsSystem, bool Complain) {
459  // Top-level options
460  if (IsSystem) {
461  if (Diags.getSuppressSystemWarnings())
462  return false;
463  // If -Wsystem-headers was not enabled before, be conservative
464  if (StoredDiags.getSuppressSystemWarnings()) {
465  if (Complain)
466  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
467  return true;
468  }
469  }
470 
471  if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
472  if (Complain)
473  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
474  return true;
475  }
476 
477  if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
478  !StoredDiags.getEnableAllWarnings()) {
479  if (Complain)
480  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
481  return true;
482  }
483 
484  if (isExtHandlingFromDiagsError(Diags) &&
485  !isExtHandlingFromDiagsError(StoredDiags)) {
486  if (Complain)
487  Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
488  return true;
489  }
490 
491  return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
492 }
493 
494 /// Return the top import module if it is implicit, nullptr otherwise.
496  Preprocessor &PP) {
497  // If the original import came from a file explicitly generated by the user,
498  // don't check the diagnostic mappings.
499  // FIXME: currently this is approximated by checking whether this is not a
500  // module import of an implicitly-loaded module file.
501  // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
502  // the transitive closure of its imports, since unrelated modules cannot be
503  // imported until after this module finishes validation.
504  ModuleFile *TopImport = &*ModuleMgr.rbegin();
505  while (!TopImport->ImportedBy.empty())
506  TopImport = TopImport->ImportedBy[0];
507  if (TopImport->Kind != MK_ImplicitModule)
508  return nullptr;
509 
510  StringRef ModuleName = TopImport->ModuleName;
511  assert(!ModuleName.empty() && "diagnostic options read before module name");
512 
513  Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
514  assert(M && "missing module");
515  return M;
516 }
517 
519  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
520  DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
521  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
523  new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
524  // This should never fail, because we would have processed these options
525  // before writing them to an ASTFile.
526  ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
527 
528  ModuleManager &ModuleMgr = Reader.getModuleManager();
529  assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
530 
531  Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
532  if (!TopM)
533  return false;
534 
535  // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
536  // contains the union of their flags.
537  return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
538  Complain);
539 }
540 
541 /// \brief Collect the macro definitions provided by the given preprocessor
542 /// options.
543 static void
545  MacroDefinitionsMap &Macros,
546  SmallVectorImpl<StringRef> *MacroNames = nullptr) {
547  for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
548  StringRef Macro = PPOpts.Macros[I].first;
549  bool IsUndef = PPOpts.Macros[I].second;
550 
551  std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
552  StringRef MacroName = MacroPair.first;
553  StringRef MacroBody = MacroPair.second;
554 
555  // For an #undef'd macro, we only care about the name.
556  if (IsUndef) {
557  if (MacroNames && !Macros.count(MacroName))
558  MacroNames->push_back(MacroName);
559 
560  Macros[MacroName] = std::make_pair("", true);
561  continue;
562  }
563 
564  // For a #define'd macro, figure out the actual definition.
565  if (MacroName.size() == Macro.size())
566  MacroBody = "1";
567  else {
568  // Note: GCC drops anything following an end-of-line character.
569  StringRef::size_type End = MacroBody.find_first_of("\n\r");
570  MacroBody = MacroBody.substr(0, End);
571  }
572 
573  if (MacroNames && !Macros.count(MacroName))
574  MacroNames->push_back(MacroName);
575  Macros[MacroName] = std::make_pair(MacroBody, false);
576  }
577 }
578 
579 /// \brief Check the preprocessor options deserialized from the control block
580 /// against the preprocessor options in an existing preprocessor.
581 ///
582 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
583 /// \param Validate If true, validate preprocessor options. If false, allow
584 /// macros defined by \p ExistingPPOpts to override those defined by
585 /// \p PPOpts in SuggestedPredefines.
587  const PreprocessorOptions &ExistingPPOpts,
588  DiagnosticsEngine *Diags,
589  FileManager &FileMgr,
590  std::string &SuggestedPredefines,
591  const LangOptions &LangOpts,
592  bool Validate = true) {
593  // Check macro definitions.
594  MacroDefinitionsMap ASTFileMacros;
595  collectMacroDefinitions(PPOpts, ASTFileMacros);
596  MacroDefinitionsMap ExistingMacros;
597  SmallVector<StringRef, 4> ExistingMacroNames;
598  collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
599 
600  for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
601  // Dig out the macro definition in the existing preprocessor options.
602  StringRef MacroName = ExistingMacroNames[I];
603  std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
604 
605  // Check whether we know anything about this macro name or not.
606  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
607  = ASTFileMacros.find(MacroName);
608  if (!Validate || Known == ASTFileMacros.end()) {
609  // FIXME: Check whether this identifier was referenced anywhere in the
610  // AST file. If so, we should reject the AST file. Unfortunately, this
611  // information isn't in the control block. What shall we do about it?
612 
613  if (Existing.second) {
614  SuggestedPredefines += "#undef ";
615  SuggestedPredefines += MacroName.str();
616  SuggestedPredefines += '\n';
617  } else {
618  SuggestedPredefines += "#define ";
619  SuggestedPredefines += MacroName.str();
620  SuggestedPredefines += ' ';
621  SuggestedPredefines += Existing.first.str();
622  SuggestedPredefines += '\n';
623  }
624  continue;
625  }
626 
627  // If the macro was defined in one but undef'd in the other, we have a
628  // conflict.
629  if (Existing.second != Known->second.second) {
630  if (Diags) {
631  Diags->Report(diag::err_pch_macro_def_undef)
632  << MacroName << Known->second.second;
633  }
634  return true;
635  }
636 
637  // If the macro was #undef'd in both, or if the macro bodies are identical,
638  // it's fine.
639  if (Existing.second || Existing.first == Known->second.first)
640  continue;
641 
642  // The macro bodies differ; complain.
643  if (Diags) {
644  Diags->Report(diag::err_pch_macro_def_conflict)
645  << MacroName << Known->second.first << Existing.first;
646  }
647  return true;
648  }
649 
650  // Check whether we're using predefines.
651  if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
652  if (Diags) {
653  Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
654  }
655  return true;
656  }
657 
658  // Detailed record is important since it is used for the module cache hash.
659  if (LangOpts.Modules &&
660  PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
661  if (Diags) {
662  Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
663  }
664  return true;
665  }
666 
667  // Compute the #include and #include_macros lines we need.
668  for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
669  StringRef File = ExistingPPOpts.Includes[I];
670  if (File == ExistingPPOpts.ImplicitPCHInclude)
671  continue;
672 
673  if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
674  != PPOpts.Includes.end())
675  continue;
676 
677  SuggestedPredefines += "#include \"";
678  SuggestedPredefines += File;
679  SuggestedPredefines += "\"\n";
680  }
681 
682  for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
683  StringRef File = ExistingPPOpts.MacroIncludes[I];
684  if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
685  File)
686  != PPOpts.MacroIncludes.end())
687  continue;
688 
689  SuggestedPredefines += "#__include_macros \"";
690  SuggestedPredefines += File;
691  SuggestedPredefines += "\"\n##\n";
692  }
693 
694  return false;
695 }
696 
698  bool Complain,
699  std::string &SuggestedPredefines) {
700  const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
701 
702  return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
703  Complain? &Reader.Diags : nullptr,
704  PP.getFileManager(),
705  SuggestedPredefines,
706  PP.getLangOpts());
707 }
708 
710  const PreprocessorOptions &PPOpts,
711  bool Complain,
712  std::string &SuggestedPredefines) {
713  return checkPreprocessorOptions(PPOpts,
714  PP.getPreprocessorOpts(),
715  nullptr,
716  PP.getFileManager(),
717  SuggestedPredefines,
718  PP.getLangOpts(),
719  false);
720 }
721 
722 /// Check the header search options deserialized from the control block
723 /// against the header search options in an existing preprocessor.
724 ///
725 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
727  StringRef SpecificModuleCachePath,
728  StringRef ExistingModuleCachePath,
729  DiagnosticsEngine *Diags,
730  const LangOptions &LangOpts) {
731  if (LangOpts.Modules) {
732  if (SpecificModuleCachePath != ExistingModuleCachePath) {
733  if (Diags)
734  Diags->Report(diag::err_pch_modulecache_mismatch)
735  << SpecificModuleCachePath << ExistingModuleCachePath;
736  return true;
737  }
738  }
739 
740  return false;
741 }
742 
744  StringRef SpecificModuleCachePath,
745  bool Complain) {
746  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
747  PP.getHeaderSearchInfo().getModuleCachePath(),
748  Complain ? &Reader.Diags : nullptr,
749  PP.getLangOpts());
750 }
751 
752 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
753  PP.setCounterValue(Value);
754 }
755 
756 //===----------------------------------------------------------------------===//
757 // AST reader implementation
758 //===----------------------------------------------------------------------===//
759 
761  bool TakeOwnership) {
762  DeserializationListener = Listener;
763  OwnsDeserializationListener = TakeOwnership;
764 }
765 
767  return serialization::ComputeHash(Sel);
768 }
769 
770 std::pair<unsigned, unsigned>
772  using namespace llvm::support;
773  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
774  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
775  return std::make_pair(KeyLen, DataLen);
776 }
777 
779 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
780  using namespace llvm::support;
781  SelectorTable &SelTable = Reader.getContext().Selectors;
782  unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
783  IdentifierInfo *FirstII = Reader.getLocalIdentifier(
784  F, endian::readNext<uint32_t, little, unaligned>(d));
785  if (N == 0)
786  return SelTable.getNullarySelector(FirstII);
787  else if (N == 1)
788  return SelTable.getUnarySelector(FirstII);
789 
791  Args.push_back(FirstII);
792  for (unsigned I = 1; I != N; ++I)
793  Args.push_back(Reader.getLocalIdentifier(
794  F, endian::readNext<uint32_t, little, unaligned>(d)));
795 
796  return SelTable.getSelector(N, Args.data());
797 }
798 
801  unsigned DataLen) {
802  using namespace llvm::support;
803 
805 
806  Result.ID = Reader.getGlobalSelectorID(
807  F, endian::readNext<uint32_t, little, unaligned>(d));
808  unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
809  unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
810  Result.InstanceBits = FullInstanceBits & 0x3;
811  Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
812  Result.FactoryBits = FullFactoryBits & 0x3;
813  Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
814  unsigned NumInstanceMethods = FullInstanceBits >> 3;
815  unsigned NumFactoryMethods = FullFactoryBits >> 3;
816 
817  // Load instance methods
818  for (unsigned I = 0; I != NumInstanceMethods; ++I) {
819  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
820  F, endian::readNext<uint32_t, little, unaligned>(d)))
821  Result.Instance.push_back(Method);
822  }
823 
824  // Load factory methods
825  for (unsigned I = 0; I != NumFactoryMethods; ++I) {
826  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
827  F, endian::readNext<uint32_t, little, unaligned>(d)))
828  Result.Factory.push_back(Method);
829  }
830 
831  return Result;
832 }
833 
835  return llvm::HashString(a);
836 }
837 
838 std::pair<unsigned, unsigned>
840  using namespace llvm::support;
841  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
842  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
843  return std::make_pair(KeyLen, DataLen);
844 }
845 
847 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
848  assert(n >= 2 && d[n-1] == '\0');
849  return StringRef((const char*) d, n-1);
850 }
851 
852 /// \brief Whether the given identifier is "interesting".
854  bool IsModule) {
855  return II.hadMacroDefinition() ||
856  II.isPoisoned() ||
857  (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
859  (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
860  II.getFETokenInfo<void>());
861 }
862 
863 static bool readBit(unsigned &Bits) {
864  bool Value = Bits & 0x1;
865  Bits >>= 1;
866  return Value;
867 }
868 
870  using namespace llvm::support;
871  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
872  return Reader.getGlobalIdentifierID(F, RawID >> 1);
873 }
874 
875 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
876  if (!II.isFromAST()) {
877  II.setIsFromAST();
878  bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
879  if (isInterestingIdentifier(Reader, II, IsModule))
881  }
882 }
883 
885  const unsigned char* d,
886  unsigned DataLen) {
887  using namespace llvm::support;
888  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
889  bool IsInteresting = RawID & 0x01;
890 
891  // Wipe out the "is interesting" bit.
892  RawID = RawID >> 1;
893 
894  // Build the IdentifierInfo and link the identifier ID with it.
895  IdentifierInfo *II = KnownII;
896  if (!II) {
897  II = &Reader.getIdentifierTable().getOwn(k);
898  KnownII = II;
899  }
900  markIdentifierFromAST(Reader, *II);
901  Reader.markIdentifierUpToDate(II);
902 
903  IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
904  if (!IsInteresting) {
905  // For uninteresting identifiers, there's nothing else to do. Just notify
906  // the reader that we've finished loading this identifier.
907  Reader.SetIdentifierInfo(ID, II);
908  return II;
909  }
910 
911  unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
912  unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
913  bool CPlusPlusOperatorKeyword = readBit(Bits);
914  bool HasRevertedTokenIDToIdentifier = readBit(Bits);
915  bool HasRevertedBuiltin = readBit(Bits);
916  bool Poisoned = readBit(Bits);
917  bool ExtensionToken = readBit(Bits);
918  bool HadMacroDefinition = readBit(Bits);
919 
920  assert(Bits == 0 && "Extra bits in the identifier?");
921  DataLen -= 8;
922 
923  // Set or check the various bits in the IdentifierInfo structure.
924  // Token IDs are read-only.
925  if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
926  II->revertTokenIDToIdentifier();
927  if (!F.isModule())
928  II->setObjCOrBuiltinID(ObjCOrBuiltinID);
929  else if (HasRevertedBuiltin && II->getBuiltinID()) {
930  II->revertBuiltin();
931  assert((II->hasRevertedBuiltin() ||
932  II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
933  "Incorrect ObjC keyword or builtin ID");
934  }
935  assert(II->isExtensionToken() == ExtensionToken &&
936  "Incorrect extension token flag");
937  (void)ExtensionToken;
938  if (Poisoned)
939  II->setIsPoisoned(true);
940  assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
941  "Incorrect C++ operator keyword flag");
942  (void)CPlusPlusOperatorKeyword;
943 
944  // If this identifier is a macro, deserialize the macro
945  // definition.
946  if (HadMacroDefinition) {
947  uint32_t MacroDirectivesOffset =
948  endian::readNext<uint32_t, little, unaligned>(d);
949  DataLen -= 4;
950 
951  Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
952  }
953 
954  Reader.SetIdentifierInfo(ID, II);
955 
956  // Read all of the declarations visible at global scope with this
957  // name.
958  if (DataLen > 0) {
959  SmallVector<uint32_t, 4> DeclIDs;
960  for (; DataLen > 0; DataLen -= 4)
961  DeclIDs.push_back(Reader.getGlobalDeclID(
962  F, endian::readNext<uint32_t, little, unaligned>(d)));
963  Reader.SetGloballyVisibleDecls(II, DeclIDs);
964  }
965 
966  return II;
967 }
968 
970  : Kind(Name.getNameKind()) {
971  switch (Kind) {
973  Data = (uint64_t)Name.getAsIdentifierInfo();
974  break;
978  Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
979  break;
981  Data = Name.getCXXOverloadedOperator();
982  break;
984  Data = (uint64_t)Name.getCXXLiteralIdentifier();
985  break;
987  Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
989  break;
994  Data = 0;
995  break;
996  }
997 }
998 
999 unsigned DeclarationNameKey::getHash() const {
1000  llvm::FoldingSetNodeID ID;
1001  ID.AddInteger(Kind);
1002 
1003  switch (Kind) {
1007  ID.AddString(((IdentifierInfo*)Data)->getName());
1008  break;
1012  ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1013  break;
1015  ID.AddInteger((OverloadedOperatorKind)Data);
1016  break;
1021  break;
1022  }
1023 
1024  return ID.ComputeHash();
1025 }
1026 
1027 ModuleFile *
1028 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1029  using namespace llvm::support;
1030  uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1031  return Reader.getLocalModuleFile(F, ModuleFileID);
1032 }
1033 
1034 std::pair<unsigned, unsigned>
1035 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1036  using namespace llvm::support;
1037  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1038  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1039  return std::make_pair(KeyLen, DataLen);
1040 }
1041 
1043 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1044  using namespace llvm::support;
1045 
1046  auto Kind = (DeclarationName::NameKind)*d++;
1047  uint64_t Data;
1048  switch (Kind) {
1052  Data = (uint64_t)Reader.getLocalIdentifier(
1053  F, endian::readNext<uint32_t, little, unaligned>(d));
1054  break;
1058  Data =
1059  (uint64_t)Reader.getLocalSelector(
1060  F, endian::readNext<uint32_t, little, unaligned>(
1061  d)).getAsOpaquePtr();
1062  break;
1064  Data = *d++; // OverloadedOperatorKind
1065  break;
1070  Data = 0;
1071  break;
1072  }
1073 
1074  return DeclarationNameKey(Kind, Data);
1075 }
1076 
1077 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1078  const unsigned char *d,
1079  unsigned DataLen,
1080  data_type_builder &Val) {
1081  using namespace llvm::support;
1082  for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1083  uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1084  Val.insert(Reader.getGlobalDeclID(F, LocalID));
1085  }
1086 }
1087 
1088 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1089  BitstreamCursor &Cursor,
1090  uint64_t Offset,
1091  DeclContext *DC) {
1092  assert(Offset != 0);
1093 
1094  SavedStreamPosition SavedPosition(Cursor);
1095  Cursor.JumpToBit(Offset);
1096 
1097  RecordData Record;
1098  StringRef Blob;
1099  unsigned Code = Cursor.ReadCode();
1100  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1101  if (RecCode != DECL_CONTEXT_LEXICAL) {
1102  Error("Expected lexical block");
1103  return true;
1104  }
1105 
1106  assert(!isa<TranslationUnitDecl>(DC) &&
1107  "expected a TU_UPDATE_LEXICAL record for TU");
1108  // If we are handling a C++ class template instantiation, we can see multiple
1109  // lexical updates for the same record. It's important that we select only one
1110  // of them, so that field numbering works properly. Just pick the first one we
1111  // see.
1112  auto &Lex = LexicalDecls[DC];
1113  if (!Lex.first) {
1114  Lex = std::make_pair(
1115  &M, llvm::makeArrayRef(
1116  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1117  Blob.data()),
1118  Blob.size() / 4));
1119  }
1120  DC->setHasExternalLexicalStorage(true);
1121  return false;
1122 }
1123 
1124 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1125  BitstreamCursor &Cursor,
1126  uint64_t Offset,
1127  DeclID ID) {
1128  assert(Offset != 0);
1129 
1130  SavedStreamPosition SavedPosition(Cursor);
1131  Cursor.JumpToBit(Offset);
1132 
1133  RecordData Record;
1134  StringRef Blob;
1135  unsigned Code = Cursor.ReadCode();
1136  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1137  if (RecCode != DECL_CONTEXT_VISIBLE) {
1138  Error("Expected visible lookup table block");
1139  return true;
1140  }
1141 
1142  // We can't safely determine the primary context yet, so delay attaching the
1143  // lookup table until we're done with recursive deserialization.
1144  auto *Data = (const unsigned char*)Blob.data();
1145  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1146  return false;
1147 }
1148 
1149 void ASTReader::Error(StringRef Msg) const {
1150  Error(diag::err_fe_pch_malformed, Msg);
1151  if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1152  !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1153  Diag(diag::note_module_cache_path)
1154  << PP.getHeaderSearchInfo().getModuleCachePath();
1155  }
1156 }
1157 
1158 void ASTReader::Error(unsigned DiagID,
1159  StringRef Arg1, StringRef Arg2) const {
1160  if (Diags.isDiagnosticInFlight())
1161  Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1162  else
1163  Diag(DiagID) << Arg1 << Arg2;
1164 }
1165 
1166 //===----------------------------------------------------------------------===//
1167 // Source Manager Deserialization
1168 //===----------------------------------------------------------------------===//
1169 
1170 /// \brief Read the line table in the source manager block.
1171 /// \returns true if there was an error.
1172 bool ASTReader::ParseLineTable(ModuleFile &F,
1173  const RecordData &Record) {
1174  unsigned Idx = 0;
1175  LineTableInfo &LineTable = SourceMgr.getLineTable();
1176 
1177  // Parse the file names
1178  std::map<int, int> FileIDs;
1179  for (unsigned I = 0; Record[Idx]; ++I) {
1180  // Extract the file name
1181  auto Filename = ReadPath(F, Record, Idx);
1182  FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1183  }
1184  ++Idx;
1185 
1186  // Parse the line entries
1187  std::vector<LineEntry> Entries;
1188  while (Idx < Record.size()) {
1189  int FID = Record[Idx++];
1190  assert(FID >= 0 && "Serialized line entries for non-local file.");
1191  // Remap FileID from 1-based old view.
1192  FID += F.SLocEntryBaseID - 1;
1193 
1194  // Extract the line entries
1195  unsigned NumEntries = Record[Idx++];
1196  assert(NumEntries && "no line entries for file ID");
1197  Entries.clear();
1198  Entries.reserve(NumEntries);
1199  for (unsigned I = 0; I != NumEntries; ++I) {
1200  unsigned FileOffset = Record[Idx++];
1201  unsigned LineNo = Record[Idx++];
1202  int FilenameID = FileIDs[Record[Idx++]];
1204  = (SrcMgr::CharacteristicKind)Record[Idx++];
1205  unsigned IncludeOffset = Record[Idx++];
1206  Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1207  FileKind, IncludeOffset));
1208  }
1209  LineTable.AddEntry(FileID::get(FID), Entries);
1210  }
1211 
1212  return false;
1213 }
1214 
1215 /// \brief Read a source manager block
1216 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1217  using namespace SrcMgr;
1218 
1219  BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1220 
1221  // Set the source-location entry cursor to the current position in
1222  // the stream. This cursor will be used to read the contents of the
1223  // source manager block initially, and then lazily read
1224  // source-location entries as needed.
1225  SLocEntryCursor = F.Stream;
1226 
1227  // The stream itself is going to skip over the source manager block.
1228  if (F.Stream.SkipBlock()) {
1229  Error("malformed block record in AST file");
1230  return true;
1231  }
1232 
1233  // Enter the source manager block.
1234  if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1235  Error("malformed source manager block record in AST file");
1236  return true;
1237  }
1238 
1239  RecordData Record;
1240  while (true) {
1241  llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1242 
1243  switch (E.Kind) {
1244  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1246  Error("malformed block record in AST file");
1247  return true;
1248  case llvm::BitstreamEntry::EndBlock:
1249  return false;
1250  case llvm::BitstreamEntry::Record:
1251  // The interesting case.
1252  break;
1253  }
1254 
1255  // Read a record.
1256  Record.clear();
1257  StringRef Blob;
1258  switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1259  default: // Default behavior: ignore.
1260  break;
1261 
1262  case SM_SLOC_FILE_ENTRY:
1263  case SM_SLOC_BUFFER_ENTRY:
1265  // Once we hit one of the source location entries, we're done.
1266  return false;
1267  }
1268  }
1269 }
1270 
1271 /// \brief If a header file is not found at the path that we expect it to be
1272 /// and the PCH file was moved from its original location, try to resolve the
1273 /// file by assuming that header+PCH were moved together and the header is in
1274 /// the same place relative to the PCH.
1275 static std::string
1277  const std::string &OriginalDir,
1278  const std::string &CurrDir) {
1279  assert(OriginalDir != CurrDir &&
1280  "No point trying to resolve the file if the PCH dir didn't change");
1281  using namespace llvm::sys;
1282  SmallString<128> filePath(Filename);
1283  fs::make_absolute(filePath);
1284  assert(path::is_absolute(OriginalDir));
1285  SmallString<128> currPCHPath(CurrDir);
1286 
1287  path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1288  fileDirE = path::end(path::parent_path(filePath));
1289  path::const_iterator origDirI = path::begin(OriginalDir),
1290  origDirE = path::end(OriginalDir);
1291  // Skip the common path components from filePath and OriginalDir.
1292  while (fileDirI != fileDirE && origDirI != origDirE &&
1293  *fileDirI == *origDirI) {
1294  ++fileDirI;
1295  ++origDirI;
1296  }
1297  for (; origDirI != origDirE; ++origDirI)
1298  path::append(currPCHPath, "..");
1299  path::append(currPCHPath, fileDirI, fileDirE);
1300  path::append(currPCHPath, path::filename(Filename));
1301  return currPCHPath.str();
1302 }
1303 
1305  if (ID == 0)
1306  return false;
1307 
1308  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1309  Error("source location entry ID out-of-range for AST file");
1310  return true;
1311  }
1312 
1313  // Local helper to read the (possibly-compressed) buffer data following the
1314  // entry record.
1315  auto ReadBuffer = [this](
1316  BitstreamCursor &SLocEntryCursor,
1317  StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1318  RecordData Record;
1319  StringRef Blob;
1320  unsigned Code = SLocEntryCursor.ReadCode();
1321  unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1322 
1323  if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1324  if (!llvm::zlib::isAvailable()) {
1325  Error("zlib is not available");
1326  return nullptr;
1327  }
1328  SmallString<0> Uncompressed;
1329  if (llvm::Error E =
1330  llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1331  Error("could not decompress embedded file contents: " +
1332  llvm::toString(std::move(E)));
1333  return nullptr;
1334  }
1335  return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1336  } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1337  return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1338  } else {
1339  Error("AST record has invalid code");
1340  return nullptr;
1341  }
1342  };
1343 
1344  ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1345  F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1346  BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1347  unsigned BaseOffset = F->SLocEntryBaseOffset;
1348 
1349  ++NumSLocEntriesRead;
1350  llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1351  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1352  Error("incorrectly-formatted source location entry in AST file");
1353  return true;
1354  }
1355 
1356  RecordData Record;
1357  StringRef Blob;
1358  switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1359  default:
1360  Error("incorrectly-formatted source location entry in AST file");
1361  return true;
1362 
1363  case SM_SLOC_FILE_ENTRY: {
1364  // We will detect whether a file changed and return 'Failure' for it, but
1365  // we will also try to fail gracefully by setting up the SLocEntry.
1366  unsigned InputID = Record[4];
1367  InputFile IF = getInputFile(*F, InputID);
1368  const FileEntry *File = IF.getFile();
1369  bool OverriddenBuffer = IF.isOverridden();
1370 
1371  // Note that we only check if a File was returned. If it was out-of-date
1372  // we have complained but we will continue creating a FileID to recover
1373  // gracefully.
1374  if (!File)
1375  return true;
1376 
1377  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1378  if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1379  // This is the module's main file.
1380  IncludeLoc = getImportLocation(F);
1381  }
1383  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1384  FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1385  ID, BaseOffset + Record[0]);
1386  SrcMgr::FileInfo &FileInfo =
1387  const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1388  FileInfo.NumCreatedFIDs = Record[5];
1389  if (Record[3])
1390  FileInfo.setHasLineDirectives();
1391 
1392  const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1393  unsigned NumFileDecls = Record[7];
1394  if (NumFileDecls && ContextObj) {
1395  assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1396  FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1397  NumFileDecls));
1398  }
1399 
1400  const SrcMgr::ContentCache *ContentCache
1401  = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1402  if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1403  ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1404  !ContentCache->getRawBuffer()) {
1405  auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1406  if (!Buffer)
1407  return true;
1408  SourceMgr.overrideFileContents(File, std::move(Buffer));
1409  }
1410 
1411  break;
1412  }
1413 
1414  case SM_SLOC_BUFFER_ENTRY: {
1415  const char *Name = Blob.data();
1416  unsigned Offset = Record[0];
1418  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1419  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1420  if (IncludeLoc.isInvalid() && F->isModule()) {
1421  IncludeLoc = getImportLocation(F);
1422  }
1423 
1424  auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1425  if (!Buffer)
1426  return true;
1427  SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1428  BaseOffset + Offset, IncludeLoc);
1429  break;
1430  }
1431 
1432  case SM_SLOC_EXPANSION_ENTRY: {
1433  SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1434  SourceMgr.createExpansionLoc(SpellingLoc,
1435  ReadSourceLocation(*F, Record[2]),
1436  ReadSourceLocation(*F, Record[3]),
1437  Record[4],
1438  ID,
1439  BaseOffset + Record[0]);
1440  break;
1441  }
1442  }
1443 
1444  return false;
1445 }
1446 
1447 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1448  if (ID == 0)
1449  return std::make_pair(SourceLocation(), "");
1450 
1451  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1452  Error("source location entry ID out-of-range for AST file");
1453  return std::make_pair(SourceLocation(), "");
1454  }
1455 
1456  // Find which module file this entry lands in.
1457  ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1458  if (!M->isModule())
1459  return std::make_pair(SourceLocation(), "");
1460 
1461  // FIXME: Can we map this down to a particular submodule? That would be
1462  // ideal.
1463  return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1464 }
1465 
1466 /// \brief Find the location where the module F is imported.
1467 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1468  if (F->ImportLoc.isValid())
1469  return F->ImportLoc;
1470 
1471  // Otherwise we have a PCH. It's considered to be "imported" at the first
1472  // location of its includer.
1473  if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1474  // Main file is the importer.
1475  assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1476  return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1477  }
1478  return F->ImportedBy[0]->FirstLoc;
1479 }
1480 
1481 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1482 /// specified cursor. Read the abbreviations that are at the top of the block
1483 /// and then leave the cursor pointing into the block.
1484 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1485  if (Cursor.EnterSubBlock(BlockID))
1486  return true;
1487 
1488  while (true) {
1489  uint64_t Offset = Cursor.GetCurrentBitNo();
1490  unsigned Code = Cursor.ReadCode();
1491 
1492  // We expect all abbrevs to be at the start of the block.
1493  if (Code != llvm::bitc::DEFINE_ABBREV) {
1494  Cursor.JumpToBit(Offset);
1495  return false;
1496  }
1497  Cursor.ReadAbbrevRecord();
1498  }
1499 }
1500 
1502  unsigned &Idx) {
1503  Token Tok;
1504  Tok.startToken();
1505  Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1506  Tok.setLength(Record[Idx++]);
1507  if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1508  Tok.setIdentifierInfo(II);
1509  Tok.setKind((tok::TokenKind)Record[Idx++]);
1510  Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1511  return Tok;
1512 }
1513 
1515  BitstreamCursor &Stream = F.MacroCursor;
1516 
1517  // Keep track of where we are in the stream, then jump back there
1518  // after reading this macro.
1519  SavedStreamPosition SavedPosition(Stream);
1520 
1521  Stream.JumpToBit(Offset);
1522  RecordData Record;
1524  MacroInfo *Macro = nullptr;
1525 
1526  while (true) {
1527  // Advance to the next record, but if we get to the end of the block, don't
1528  // pop it (removing all the abbreviations from the cursor) since we want to
1529  // be able to reseek within the block and read entries.
1530  unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1531  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1532 
1533  switch (Entry.Kind) {
1534  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1536  Error("malformed block record in AST file");
1537  return Macro;
1538  case llvm::BitstreamEntry::EndBlock:
1539  return Macro;
1540  case llvm::BitstreamEntry::Record:
1541  // The interesting case.
1542  break;
1543  }
1544 
1545  // Read a record.
1546  Record.clear();
1547  PreprocessorRecordTypes RecType =
1548  (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1549  switch (RecType) {
1550  case PP_MODULE_MACRO:
1552  return Macro;
1553 
1554  case PP_MACRO_OBJECT_LIKE:
1555  case PP_MACRO_FUNCTION_LIKE: {
1556  // If we already have a macro, that means that we've hit the end
1557  // of the definition of the macro we were looking for. We're
1558  // done.
1559  if (Macro)
1560  return Macro;
1561 
1562  unsigned NextIndex = 1; // Skip identifier ID.
1563  SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1564  MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1565  MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1566  MI->setIsUsed(Record[NextIndex++]);
1567  MI->setUsedForHeaderGuard(Record[NextIndex++]);
1568 
1569  if (RecType == PP_MACRO_FUNCTION_LIKE) {
1570  // Decode function-like macro info.
1571  bool isC99VarArgs = Record[NextIndex++];
1572  bool isGNUVarArgs = Record[NextIndex++];
1573  bool hasCommaPasting = Record[NextIndex++];
1574  MacroParams.clear();
1575  unsigned NumArgs = Record[NextIndex++];
1576  for (unsigned i = 0; i != NumArgs; ++i)
1577  MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1578 
1579  // Install function-like macro info.
1580  MI->setIsFunctionLike();
1581  if (isC99VarArgs) MI->setIsC99Varargs();
1582  if (isGNUVarArgs) MI->setIsGNUVarargs();
1583  if (hasCommaPasting) MI->setHasCommaPasting();
1584  MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1585  }
1586 
1587  // Remember that we saw this macro last so that we add the tokens that
1588  // form its body to it.
1589  Macro = MI;
1590 
1591  if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1592  Record[NextIndex]) {
1593  // We have a macro definition. Register the association
1595  GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1596  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1597  PreprocessingRecord::PPEntityID PPID =
1598  PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1599  MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1600  PPRec.getPreprocessedEntity(PPID));
1601  if (PPDef)
1602  PPRec.RegisterMacroDefinition(Macro, PPDef);
1603  }
1604 
1605  ++NumMacrosRead;
1606  break;
1607  }
1608 
1609  case PP_TOKEN: {
1610  // If we see a TOKEN before a PP_MACRO_*, then the file is
1611  // erroneous, just pretend we didn't see this.
1612  if (!Macro) break;
1613 
1614  unsigned Idx = 0;
1615  Token Tok = ReadToken(F, Record, Idx);
1616  Macro->AddTokenToBody(Tok);
1617  break;
1618  }
1619  }
1620  }
1621 }
1622 
1625  unsigned LocalID) const {
1626  if (!M.ModuleOffsetMap.empty())
1627  ReadModuleOffsetMap(M);
1628 
1631  assert(I != M.PreprocessedEntityRemap.end()
1632  && "Invalid index into preprocessed entity index remap");
1633 
1634  return LocalID + I->second;
1635 }
1636 
1638  return llvm::hash_combine(ikey.Size, ikey.ModTime);
1639 }
1640 
1642 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1643  internal_key_type ikey = {FE->getSize(),
1644  M.HasTimestamps ? FE->getModificationTime() : 0,
1645  FE->getName(), /*Imported*/ false};
1646  return ikey;
1647 }
1648 
1649 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1650  if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1651  return false;
1652 
1653  if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1654  return true;
1655 
1656  // Determine whether the actual files are equivalent.
1657  FileManager &FileMgr = Reader.getFileManager();
1658  auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1659  if (!Key.Imported)
1660  return FileMgr.getFile(Key.Filename);
1661 
1662  std::string Resolved = Key.Filename;
1663  Reader.ResolveImportedPath(M, Resolved);
1664  return FileMgr.getFile(Resolved);
1665  };
1666 
1667  const FileEntry *FEA = GetFile(a);
1668  const FileEntry *FEB = GetFile(b);
1669  return FEA && FEA == FEB;
1670 }
1671 
1672 std::pair<unsigned, unsigned>
1673 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1674  using namespace llvm::support;
1675  unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1676  unsigned DataLen = (unsigned) *d++;
1677  return std::make_pair(KeyLen, DataLen);
1678 }
1679 
1681 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1682  using namespace llvm::support;
1683  internal_key_type ikey;
1684  ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1685  ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1686  ikey.Filename = (const char *)d;
1687  ikey.Imported = true;
1688  return ikey;
1689 }
1690 
1692 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1693  unsigned DataLen) {
1694  const unsigned char *End = d + DataLen;
1695  using namespace llvm::support;
1696  HeaderFileInfo HFI;
1697  unsigned Flags = *d++;
1698  // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1699  HFI.isImport |= (Flags >> 5) & 0x01;
1700  HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1701  HFI.DirInfo = (Flags >> 1) & 0x07;
1702  HFI.IndexHeaderMapHeader = Flags & 0x01;
1703  // FIXME: Find a better way to handle this. Maybe just store a
1704  // "has been included" flag?
1705  HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1706  HFI.NumIncludes);
1707  HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1708  M, endian::readNext<uint32_t, little, unaligned>(d));
1709  if (unsigned FrameworkOffset =
1710  endian::readNext<uint32_t, little, unaligned>(d)) {
1711  // The framework offset is 1 greater than the actual offset,
1712  // since 0 is used as an indicator for "no framework name".
1713  StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1714  HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1715  }
1716 
1717  assert((End - d) % 4 == 0 &&
1718  "Wrong data length in HeaderFileInfo deserialization");
1719  while (d != End) {
1720  uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1721  auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1722  LocalSMID >>= 2;
1723 
1724  // This header is part of a module. Associate it with the module to enable
1725  // implicit module import.
1726  SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1727  Module *Mod = Reader.getSubmodule(GlobalSMID);
1728  FileManager &FileMgr = Reader.getFileManager();
1729  ModuleMap &ModMap =
1730  Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1731 
1732  std::string Filename = key.Filename;
1733  if (key.Imported)
1734  Reader.ResolveImportedPath(M, Filename);
1735  // FIXME: This is not always the right filename-as-written, but we're not
1736  // going to use this information to rebuild the module, so it doesn't make
1737  // a lot of difference.
1738  Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1739  ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1740  HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1741  }
1742 
1743  // This HeaderFileInfo was externally loaded.
1744  HFI.External = true;
1745  HFI.IsValid = true;
1746  return HFI;
1747 }
1748 
1750  ModuleFile *M,
1751  uint64_t MacroDirectivesOffset) {
1752  assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1753  PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1754 }
1755 
1757  // Note that we are loading defined macros.
1758  Deserializing Macros(this);
1759 
1760  for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1761  BitstreamCursor &MacroCursor = I.MacroCursor;
1762 
1763  // If there was no preprocessor block, skip this file.
1764  if (MacroCursor.getBitcodeBytes().empty())
1765  continue;
1766 
1767  BitstreamCursor Cursor = MacroCursor;
1768  Cursor.JumpToBit(I.MacroStartOffset);
1769 
1770  RecordData Record;
1771  while (true) {
1772  llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1773 
1774  switch (E.Kind) {
1775  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1777  Error("malformed block record in AST file");
1778  return;
1779  case llvm::BitstreamEntry::EndBlock:
1780  goto NextCursor;
1781 
1782  case llvm::BitstreamEntry::Record:
1783  Record.clear();
1784  switch (Cursor.readRecord(E.ID, Record)) {
1785  default: // Default behavior: ignore.
1786  break;
1787 
1788  case PP_MACRO_OBJECT_LIKE:
1789  case PP_MACRO_FUNCTION_LIKE: {
1790  IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1791  if (II->isOutOfDate())
1792  updateOutOfDateIdentifier(*II);
1793  break;
1794  }
1795 
1796  case PP_TOKEN:
1797  // Ignore tokens.
1798  break;
1799  }
1800  break;
1801  }
1802  }
1803  NextCursor: ;
1804  }
1805 }
1806 
1807 namespace {
1808 
1809  /// \brief Visitor class used to look up identifirs in an AST file.
1810  class IdentifierLookupVisitor {
1811  StringRef Name;
1812  unsigned NameHash;
1813  unsigned PriorGeneration;
1814  unsigned &NumIdentifierLookups;
1815  unsigned &NumIdentifierLookupHits;
1816  IdentifierInfo *Found;
1817 
1818  public:
1819  IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1820  unsigned &NumIdentifierLookups,
1821  unsigned &NumIdentifierLookupHits)
1822  : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1823  PriorGeneration(PriorGeneration),
1824  NumIdentifierLookups(NumIdentifierLookups),
1825  NumIdentifierLookupHits(NumIdentifierLookupHits),
1826  Found()
1827  {
1828  }
1829 
1830  bool operator()(ModuleFile &M) {
1831  // If we've already searched this module file, skip it now.
1832  if (M.Generation <= PriorGeneration)
1833  return true;
1834 
1835  ASTIdentifierLookupTable *IdTable
1837  if (!IdTable)
1838  return false;
1839 
1840  ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1841  Found);
1842  ++NumIdentifierLookups;
1843  ASTIdentifierLookupTable::iterator Pos =
1844  IdTable->find_hashed(Name, NameHash, &Trait);
1845  if (Pos == IdTable->end())
1846  return false;
1847 
1848  // Dereferencing the iterator has the effect of building the
1849  // IdentifierInfo node and populating it with the various
1850  // declarations it needs.
1851  ++NumIdentifierLookupHits;
1852  Found = *Pos;
1853  return true;
1854  }
1855 
1856  // \brief Retrieve the identifier info found within the module
1857  // files.
1858  IdentifierInfo *getIdentifierInfo() const { return Found; }
1859  };
1860 
1861 } // end anonymous namespace
1862 
1864  // Note that we are loading an identifier.
1865  Deserializing AnIdentifier(this);
1866 
1867  unsigned PriorGeneration = 0;
1868  if (getContext().getLangOpts().Modules)
1869  PriorGeneration = IdentifierGeneration[&II];
1870 
1871  // If there is a global index, look there first to determine which modules
1872  // provably do not have any results for this identifier.
1874  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1875  if (!loadGlobalIndex()) {
1876  if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1877  HitsPtr = &Hits;
1878  }
1879  }
1880 
1881  IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1882  NumIdentifierLookups,
1883  NumIdentifierLookupHits);
1884  ModuleMgr.visit(Visitor, HitsPtr);
1885  markIdentifierUpToDate(&II);
1886 }
1887 
1889  if (!II)
1890  return;
1891 
1892  II->setOutOfDate(false);
1893 
1894  // Update the generation for this identifier.
1895  if (getContext().getLangOpts().Modules)
1896  IdentifierGeneration[II] = getGeneration();
1897 }
1898 
1900  const PendingMacroInfo &PMInfo) {
1901  ModuleFile &M = *PMInfo.M;
1902 
1903  BitstreamCursor &Cursor = M.MacroCursor;
1904  SavedStreamPosition SavedPosition(Cursor);
1905  Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1906 
1907  struct ModuleMacroRecord {
1908  SubmoduleID SubModID;
1909  MacroInfo *MI;
1910  SmallVector<SubmoduleID, 8> Overrides;
1911  };
1913 
1914  // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1915  // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1916  // macro histroy.
1917  RecordData Record;
1918  while (true) {
1919  llvm::BitstreamEntry Entry =
1920  Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1921  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1922  Error("malformed block record in AST file");
1923  return;
1924  }
1925 
1926  Record.clear();
1927  switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1929  break;
1930 
1931  case PP_MODULE_MACRO: {
1932  ModuleMacros.push_back(ModuleMacroRecord());
1933  auto &Info = ModuleMacros.back();
1934  Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1935  Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1936  for (int I = 2, N = Record.size(); I != N; ++I)
1937  Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1938  continue;
1939  }
1940 
1941  default:
1942  Error("malformed block record in AST file");
1943  return;
1944  }
1945 
1946  // We found the macro directive history; that's the last record
1947  // for this macro.
1948  break;
1949  }
1950 
1951  // Module macros are listed in reverse dependency order.
1952  {
1953  std::reverse(ModuleMacros.begin(), ModuleMacros.end());
1955  for (auto &MMR : ModuleMacros) {
1956  Overrides.clear();
1957  for (unsigned ModID : MMR.Overrides) {
1958  Module *Mod = getSubmodule(ModID);
1959  auto *Macro = PP.getModuleMacro(Mod, II);
1960  assert(Macro && "missing definition for overridden macro");
1961  Overrides.push_back(Macro);
1962  }
1963 
1964  bool Inserted = false;
1965  Module *Owner = getSubmodule(MMR.SubModID);
1966  PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
1967  }
1968  }
1969 
1970  // Don't read the directive history for a module; we don't have anywhere
1971  // to put it.
1972  if (M.isModule())
1973  return;
1974 
1975  // Deserialize the macro directives history in reverse source-order.
1976  MacroDirective *Latest = nullptr, *Earliest = nullptr;
1977  unsigned Idx = 0, N = Record.size();
1978  while (Idx < N) {
1979  MacroDirective *MD = nullptr;
1980  SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
1981  MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
1982  switch (K) {
1984  MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
1985  MD = PP.AllocateDefMacroDirective(MI, Loc);
1986  break;
1987  }
1989  MD = PP.AllocateUndefMacroDirective(Loc);
1990  break;
1991  }
1993  bool isPublic = Record[Idx++];
1994  MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
1995  break;
1996  }
1997 
1998  if (!Latest)
1999  Latest = MD;
2000  if (Earliest)
2001  Earliest->setPrevious(MD);
2002  Earliest = MD;
2003  }
2004 
2005  if (Latest)
2006  PP.setLoadedMacroDirective(II, Earliest, Latest);
2007 }
2008 
2009 ASTReader::InputFileInfo
2010 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2011  // Go find this input file.
2012  BitstreamCursor &Cursor = F.InputFilesCursor;
2013  SavedStreamPosition SavedPosition(Cursor);
2014  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2015 
2016  unsigned Code = Cursor.ReadCode();
2017  RecordData Record;
2018  StringRef Blob;
2019 
2020  unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2021  assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2022  "invalid record type for input file");
2023  (void)Result;
2024 
2025  assert(Record[0] == ID && "Bogus stored ID or offset");
2026  InputFileInfo R;
2027  R.StoredSize = static_cast<off_t>(Record[1]);
2028  R.StoredTime = static_cast<time_t>(Record[2]);
2029  R.Overridden = static_cast<bool>(Record[3]);
2030  R.Transient = static_cast<bool>(Record[4]);
2031  R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2032  R.Filename = Blob;
2033  ResolveImportedPath(F, R.Filename);
2034  return R;
2035 }
2036 
2037 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2038 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2039  // If this ID is bogus, just return an empty input file.
2040  if (ID == 0 || ID > F.InputFilesLoaded.size())
2041  return InputFile();
2042 
2043  // If we've already loaded this input file, return it.
2044  if (F.InputFilesLoaded[ID-1].getFile())
2045  return F.InputFilesLoaded[ID-1];
2046 
2047  if (F.InputFilesLoaded[ID-1].isNotFound())
2048  return InputFile();
2049 
2050  // Go find this input file.
2051  BitstreamCursor &Cursor = F.InputFilesCursor;
2052  SavedStreamPosition SavedPosition(Cursor);
2053  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2054 
2055  InputFileInfo FI = readInputFileInfo(F, ID);
2056  off_t StoredSize = FI.StoredSize;
2057  time_t StoredTime = FI.StoredTime;
2058  bool Overridden = FI.Overridden;
2059  bool Transient = FI.Transient;
2060  StringRef Filename = FI.Filename;
2061 
2062  const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2063 
2064  // If we didn't find the file, resolve it relative to the
2065  // original directory from which this AST file was created.
2066  if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
2067  F.OriginalDir != CurrentDir) {
2068  std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
2069  F.OriginalDir,
2070  CurrentDir);
2071  if (!Resolved.empty())
2072  File = FileMgr.getFile(Resolved);
2073  }
2074 
2075  // For an overridden file, create a virtual file with the stored
2076  // size/timestamp.
2077  if ((Overridden || Transient) && File == nullptr)
2078  File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2079 
2080  if (File == nullptr) {
2081  if (Complain) {
2082  std::string ErrorStr = "could not find file '";
2083  ErrorStr += Filename;
2084  ErrorStr += "' referenced by AST file '";
2085  ErrorStr += F.FileName;
2086  ErrorStr += "'";
2087  Error(ErrorStr);
2088  }
2089  // Record that we didn't find the file.
2091  return InputFile();
2092  }
2093 
2094  // Check if there was a request to override the contents of the file
2095  // that was part of the precompiled header. Overridding such a file
2096  // can lead to problems when lexing using the source locations from the
2097  // PCH.
2098  SourceManager &SM = getSourceManager();
2099  // FIXME: Reject if the overrides are different.
2100  if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2101  if (Complain)
2102  Error(diag::err_fe_pch_file_overridden, Filename);
2103  // After emitting the diagnostic, recover by disabling the override so
2104  // that the original file will be used.
2105  //
2106  // FIXME: This recovery is just as broken as the original state; there may
2107  // be another precompiled module that's using the overridden contents, or
2108  // we might be half way through parsing it. Instead, we should treat the
2109  // overridden contents as belonging to a separate FileEntry.
2110  SM.disableFileContentsOverride(File);
2111  // The FileEntry is a virtual file entry with the size of the contents
2112  // that would override the original contents. Set it to the original's
2113  // size/time.
2114  FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2115  StoredSize, StoredTime);
2116  }
2117 
2118  bool IsOutOfDate = false;
2119 
2120  // For an overridden file, there is nothing to validate.
2121  if (!Overridden && //
2122  (StoredSize != File->getSize() ||
2123  (StoredTime && StoredTime != File->getModificationTime() &&
2124  !DisableValidation)
2125  )) {
2126  if (Complain) {
2127  // Build a list of the PCH imports that got us here (in reverse).
2128  SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2129  while (ImportStack.back()->ImportedBy.size() > 0)
2130  ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2131 
2132  // The top-level PCH is stale.
2133  StringRef TopLevelPCHName(ImportStack.back()->FileName);
2134  unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2135  if (DiagnosticKind == 0)
2136  Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2137  else if (DiagnosticKind == 1)
2138  Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2139  else
2140  Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2141 
2142  // Print the import stack.
2143  if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2144  Diag(diag::note_pch_required_by)
2145  << Filename << ImportStack[0]->FileName;
2146  for (unsigned I = 1; I < ImportStack.size(); ++I)
2147  Diag(diag::note_pch_required_by)
2148  << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2149  }
2150 
2151  if (!Diags.isDiagnosticInFlight())
2152  Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2153  }
2154 
2155  IsOutOfDate = true;
2156  }
2157  // FIXME: If the file is overridden and we've already opened it,
2158  // issue an error (or split it into a separate FileEntry).
2159 
2160  InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2161 
2162  // Note that we've loaded this input file.
2163  F.InputFilesLoaded[ID-1] = IF;
2164  return IF;
2165 }
2166 
2167 /// \brief If we are loading a relocatable PCH or module file, and the filename
2168 /// is not an absolute path, add the system or module root to the beginning of
2169 /// the file name.
2170 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2171  // Resolve relative to the base directory, if we have one.
2172  if (!M.BaseDirectory.empty())
2173  return ResolveImportedPath(Filename, M.BaseDirectory);
2174 }
2175 
2176 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2177  if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2178  return;
2179 
2181  llvm::sys::path::append(Buffer, Prefix, Filename);
2182  Filename.assign(Buffer.begin(), Buffer.end());
2183 }
2184 
2185 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2186  switch (ARR) {
2187  case ASTReader::Failure: return true;
2188  case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2189  case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2192  return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2193  case ASTReader::HadErrors: return true;
2194  case ASTReader::Success: return false;
2195  }
2196 
2197  llvm_unreachable("unknown ASTReadResult");
2198 }
2199 
2200 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2201  BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2202  bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2203  std::string &SuggestedPredefines) {
2204  if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2205  return Failure;
2206 
2207  // Read all of the records in the options block.
2208  RecordData Record;
2209  ASTReadResult Result = Success;
2210  while (true) {
2211  llvm::BitstreamEntry Entry = Stream.advance();
2212 
2213  switch (Entry.Kind) {
2215  case llvm::BitstreamEntry::SubBlock:
2216  return Failure;
2217 
2218  case llvm::BitstreamEntry::EndBlock:
2219  return Result;
2220 
2221  case llvm::BitstreamEntry::Record:
2222  // The interesting case.
2223  break;
2224  }
2225 
2226  // Read and process a record.
2227  Record.clear();
2228  switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2229  case LANGUAGE_OPTIONS: {
2230  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2231  if (ParseLanguageOptions(Record, Complain, Listener,
2232  AllowCompatibleConfigurationMismatch))
2233  Result = ConfigurationMismatch;
2234  break;
2235  }
2236 
2237  case TARGET_OPTIONS: {
2238  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2239  if (ParseTargetOptions(Record, Complain, Listener,
2240  AllowCompatibleConfigurationMismatch))
2241  Result = ConfigurationMismatch;
2242  break;
2243  }
2244 
2245  case FILE_SYSTEM_OPTIONS: {
2246  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2247  if (!AllowCompatibleConfigurationMismatch &&
2248  ParseFileSystemOptions(Record, Complain, Listener))
2249  Result = ConfigurationMismatch;
2250  break;
2251  }
2252 
2253  case HEADER_SEARCH_OPTIONS: {
2254  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2255  if (!AllowCompatibleConfigurationMismatch &&
2256  ParseHeaderSearchOptions(Record, Complain, Listener))
2257  Result = ConfigurationMismatch;
2258  break;
2259  }
2260 
2261  case PREPROCESSOR_OPTIONS:
2262  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2263  if (!AllowCompatibleConfigurationMismatch &&
2264  ParsePreprocessorOptions(Record, Complain, Listener,
2265  SuggestedPredefines))
2266  Result = ConfigurationMismatch;
2267  break;
2268  }
2269  }
2270 }
2271 
2273 ASTReader::ReadControlBlock(ModuleFile &F,
2275  const ModuleFile *ImportedBy,
2276  unsigned ClientLoadCapabilities) {
2277  BitstreamCursor &Stream = F.Stream;
2278  ASTReadResult Result = Success;
2279 
2280  if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2281  Error("malformed block record in AST file");
2282  return Failure;
2283  }
2284 
2285  // Lambda to read the unhashed control block the first time it's called.
2286  //
2287  // For PCM files, the unhashed control block cannot be read until after the
2288  // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2289  // need to look ahead before reading the IMPORTS record. For consistency,
2290  // this block is always read somehow (see BitstreamEntry::EndBlock).
2291  bool HasReadUnhashedControlBlock = false;
2292  auto readUnhashedControlBlockOnce = [&]() {
2293  if (!HasReadUnhashedControlBlock) {
2294  HasReadUnhashedControlBlock = true;
2295  if (ASTReadResult Result =
2296  readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2297  return Result;
2298  }
2299  return Success;
2300  };
2301 
2302  // Read all of the records and blocks in the control block.
2303  RecordData Record;
2304  unsigned NumInputs = 0;
2305  unsigned NumUserInputs = 0;
2306  while (true) {
2307  llvm::BitstreamEntry Entry = Stream.advance();
2308 
2309  switch (Entry.Kind) {
2311  Error("malformed block record in AST file");
2312  return Failure;
2313  case llvm::BitstreamEntry::EndBlock: {
2314  // Validate the module before returning. This call catches an AST with
2315  // no module name and no imports.
2316  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2317  return Result;
2318 
2319  // Validate input files.
2320  const HeaderSearchOptions &HSOpts =
2321  PP.getHeaderSearchInfo().getHeaderSearchOpts();
2322 
2323  // All user input files reside at the index range [0, NumUserInputs), and
2324  // system input files reside at [NumUserInputs, NumInputs). For explicitly
2325  // loaded module files, ignore missing inputs.
2326  if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2327  F.Kind != MK_PrebuiltModule) {
2328  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2329 
2330  // If we are reading a module, we will create a verification timestamp,
2331  // so we verify all input files. Otherwise, verify only user input
2332  // files.
2333 
2334  unsigned N = NumUserInputs;
2335  if (ValidateSystemInputs ||
2338  F.Kind == MK_ImplicitModule))
2339  N = NumInputs;
2340 
2341  for (unsigned I = 0; I < N; ++I) {
2342  InputFile IF = getInputFile(F, I+1, Complain);
2343  if (!IF.getFile() || IF.isOutOfDate())
2344  return OutOfDate;
2345  }
2346  }
2347 
2348  if (Listener)
2349  Listener->visitModuleFile(F.FileName, F.Kind);
2350 
2351  if (Listener && Listener->needsInputFileVisitation()) {
2352  unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2353  : NumUserInputs;
2354  for (unsigned I = 0; I < N; ++I) {
2355  bool IsSystem = I >= NumUserInputs;
2356  InputFileInfo FI = readInputFileInfo(F, I+1);
2357  Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2358  F.Kind == MK_ExplicitModule ||
2359  F.Kind == MK_PrebuiltModule);
2360  }
2361  }
2362 
2363  return Result;
2364  }
2365 
2366  case llvm::BitstreamEntry::SubBlock:
2367  switch (Entry.ID) {
2368  case INPUT_FILES_BLOCK_ID:
2369  F.InputFilesCursor = Stream;
2370  if (Stream.SkipBlock() || // Skip with the main cursor
2371  // Read the abbreviations
2372  ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2373  Error("malformed block record in AST file");
2374  return Failure;
2375  }
2376  continue;
2377 
2378  case OPTIONS_BLOCK_ID:
2379  // If we're reading the first module for this group, check its options
2380  // are compatible with ours. For modules it imports, no further checking
2381  // is required, because we checked them when we built it.
2382  if (Listener && !ImportedBy) {
2383  // Should we allow the configuration of the module file to differ from
2384  // the configuration of the current translation unit in a compatible
2385  // way?
2386  //
2387  // FIXME: Allow this for files explicitly specified with -include-pch.
2388  bool AllowCompatibleConfigurationMismatch =
2390 
2391  Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2392  AllowCompatibleConfigurationMismatch,
2393  *Listener, SuggestedPredefines);
2394  if (Result == Failure) {
2395  Error("malformed block record in AST file");
2396  return Result;
2397  }
2398 
2399  if (DisableValidation ||
2400  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2401  Result = Success;
2402 
2403  // If we can't load the module, exit early since we likely
2404  // will rebuild the module anyway. The stream may be in the
2405  // middle of a block.
2406  if (Result != Success)
2407  return Result;
2408  } else if (Stream.SkipBlock()) {
2409  Error("malformed block record in AST file");
2410  return Failure;
2411  }
2412  continue;
2413 
2414  default:
2415  if (Stream.SkipBlock()) {
2416  Error("malformed block record in AST file");
2417  return Failure;
2418  }
2419  continue;
2420  }
2421 
2422  case llvm::BitstreamEntry::Record:
2423  // The interesting case.
2424  break;
2425  }
2426 
2427  // Read and process a record.
2428  Record.clear();
2429  StringRef Blob;
2430  switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2431  case METADATA: {
2432  if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2433  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2434  Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2435  : diag::err_pch_version_too_new);
2436  return VersionMismatch;
2437  }
2438 
2439  bool hasErrors = Record[6];
2440  if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2441  Diag(diag::err_pch_with_compiler_errors);
2442  return HadErrors;
2443  }
2444  if (hasErrors) {
2445  Diags.ErrorOccurred = true;
2446  Diags.UncompilableErrorOccurred = true;
2447  Diags.UnrecoverableErrorOccurred = true;
2448  }
2449 
2450  F.RelocatablePCH = Record[4];
2451  // Relative paths in a relocatable PCH are relative to our sysroot.
2452  if (F.RelocatablePCH)
2453  F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2454 
2455  F.HasTimestamps = Record[5];
2456 
2457  const std::string &CurBranch = getClangFullRepositoryVersion();
2458  StringRef ASTBranch = Blob;
2459  if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2460  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2461  Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2462  return VersionMismatch;
2463  }
2464  break;
2465  }
2466 
2467  case IMPORTS: {
2468  // Validate the AST before processing any imports (otherwise, untangling
2469  // them can be error-prone and expensive). A module will have a name and
2470  // will already have been validated, but this catches the PCH case.
2471  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2472  return Result;
2473 
2474  // Load each of the imported PCH files.
2475  unsigned Idx = 0, N = Record.size();
2476  while (Idx < N) {
2477  // Read information about the AST file.
2478  ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2479  // The import location will be the local one for now; we will adjust
2480  // all import locations of module imports after the global source
2481  // location info are setup, in ReadAST.
2482  SourceLocation ImportLoc =
2483  ReadUntranslatedSourceLocation(Record[Idx++]);
2484  off_t StoredSize = (off_t)Record[Idx++];
2485  time_t StoredModTime = (time_t)Record[Idx++];
2486  ASTFileSignature StoredSignature = {
2487  {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2488  (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2489  (uint32_t)Record[Idx++]}}};
2490  auto ImportedFile = ReadPath(F, Record, Idx);
2491 
2492  // If our client can't cope with us being out of date, we can't cope with
2493  // our dependency being missing.
2494  unsigned Capabilities = ClientLoadCapabilities;
2495  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2496  Capabilities &= ~ARR_Missing;
2497 
2498  // Load the AST file.
2499  auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2500  Loaded, StoredSize, StoredModTime,
2501  StoredSignature, Capabilities);
2502 
2503  // If we diagnosed a problem, produce a backtrace.
2504  if (isDiagnosedResult(Result, Capabilities))
2505  Diag(diag::note_module_file_imported_by)
2506  << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2507 
2508  switch (Result) {
2509  case Failure: return Failure;
2510  // If we have to ignore the dependency, we'll have to ignore this too.
2511  case Missing:
2512  case OutOfDate: return OutOfDate;
2513  case VersionMismatch: return VersionMismatch;
2514  case ConfigurationMismatch: return ConfigurationMismatch;
2515  case HadErrors: return HadErrors;
2516  case Success: break;
2517  }
2518  }
2519  break;
2520  }
2521 
2522  case ORIGINAL_FILE:
2523  F.OriginalSourceFileID = FileID::get(Record[0]);
2526  ResolveImportedPath(F, F.OriginalSourceFileName);
2527  break;
2528 
2529  case ORIGINAL_FILE_ID:
2530  F.OriginalSourceFileID = FileID::get(Record[0]);
2531  break;
2532 
2533  case ORIGINAL_PCH_DIR:
2534  F.OriginalDir = Blob;
2535  break;
2536 
2537  case MODULE_NAME:
2538  F.ModuleName = Blob;
2539  if (Listener)
2540  Listener->ReadModuleName(F.ModuleName);
2541 
2542  // Validate the AST as soon as we have a name so we can exit early on
2543  // failure.
2544  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2545  return Result;
2546 
2547  break;
2548 
2549  case MODULE_DIRECTORY: {
2550  assert(!F.ModuleName.empty() &&
2551  "MODULE_DIRECTORY found before MODULE_NAME");
2552  // If we've already loaded a module map file covering this module, we may
2553  // have a better path for it (relative to the current build).
2554  Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
2555  if (M && M->Directory) {
2556  // If we're implicitly loading a module, the base directory can't
2557  // change between the build and use.
2558  if (F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2559  const DirectoryEntry *BuildDir =
2560  PP.getFileManager().getDirectory(Blob);
2561  if (!BuildDir || BuildDir != M->Directory) {
2562  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2563  Diag(diag::err_imported_module_relocated)
2564  << F.ModuleName << Blob << M->Directory->getName();
2565  return OutOfDate;
2566  }
2567  }
2568  F.BaseDirectory = M->Directory->getName();
2569  } else {
2570  F.BaseDirectory = Blob;
2571  }
2572  break;
2573  }
2574 
2575  case MODULE_MAP_FILE:
2576  if (ASTReadResult Result =
2577  ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2578  return Result;
2579  break;
2580 
2581  case INPUT_FILE_OFFSETS:
2582  NumInputs = Record[0];
2583  NumUserInputs = Record[1];
2584  F.InputFileOffsets =
2585  (const llvm::support::unaligned_uint64_t *)Blob.data();
2586  F.InputFilesLoaded.resize(NumInputs);
2587  F.NumUserInputFiles = NumUserInputs;
2588  break;
2589  }
2590  }
2591 }
2592 
2594 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2595  BitstreamCursor &Stream = F.Stream;
2596 
2597  if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2598  Error("malformed block record in AST file");
2599  return Failure;
2600  }
2601 
2602  // Read all of the records and blocks for the AST file.
2603  RecordData Record;
2604  while (true) {
2605  llvm::BitstreamEntry Entry = Stream.advance();
2606 
2607  switch (Entry.Kind) {
2609  Error("error at end of module block in AST file");
2610  return Failure;
2611  case llvm::BitstreamEntry::EndBlock: {
2612  // Outside of C++, we do not store a lookup map for the translation unit.
2613  // Instead, mark it as needing a lookup map to be built if this module
2614  // contains any declarations lexically within it (which it always does!).
2615  // This usually has no cost, since we very rarely need the lookup map for
2616  // the translation unit outside C++.
2617  if (ASTContext *Ctx = ContextObj) {
2618  DeclContext *DC = Ctx->getTranslationUnitDecl();
2619  if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2621  }
2622 
2623  return Success;
2624  }
2625  case llvm::BitstreamEntry::SubBlock:
2626  switch (Entry.ID) {
2627  case DECLTYPES_BLOCK_ID:
2628  // We lazily load the decls block, but we want to set up the
2629  // DeclsCursor cursor to point into it. Clone our current bitcode
2630  // cursor to it, enter the block and read the abbrevs in that block.
2631  // With the main cursor, we just skip over it.
2632  F.DeclsCursor = Stream;
2633  if (Stream.SkipBlock() || // Skip with the main cursor.
2634  // Read the abbrevs.
2635  ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2636  Error("malformed block record in AST file");
2637  return Failure;
2638  }
2639  break;
2640 
2641  case PREPROCESSOR_BLOCK_ID:
2642  F.MacroCursor = Stream;
2643  if (!PP.getExternalSource())
2644  PP.setExternalSource(this);
2645 
2646  if (Stream.SkipBlock() ||
2647  ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2648  Error("malformed block record in AST file");
2649  return Failure;
2650  }
2651  F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2652  break;
2653 
2655  F.PreprocessorDetailCursor = Stream;
2656  if (Stream.SkipBlock() ||
2657  ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2659  Error("malformed preprocessor detail record in AST file");
2660  return Failure;
2661  }
2663  = F.PreprocessorDetailCursor.GetCurrentBitNo();
2664 
2665  if (!PP.getPreprocessingRecord())
2666  PP.createPreprocessingRecord();
2667  if (!PP.getPreprocessingRecord()->getExternalSource())
2668  PP.getPreprocessingRecord()->SetExternalSource(*this);
2669  break;
2670 
2672  if (ReadSourceManagerBlock(F))
2673  return Failure;
2674  break;
2675 
2676  case SUBMODULE_BLOCK_ID:
2677  if (ASTReadResult Result =
2678  ReadSubmoduleBlock(F, ClientLoadCapabilities))
2679  return Result;
2680  break;
2681 
2682  case COMMENTS_BLOCK_ID: {
2683  BitstreamCursor C = Stream;
2684  if (Stream.SkipBlock() ||
2685  ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2686  Error("malformed comments block in AST file");
2687  return Failure;
2688  }
2689  CommentsCursors.push_back(std::make_pair(C, &F));
2690  break;
2691  }
2692 
2693  default:
2694  if (Stream.SkipBlock()) {
2695  Error("malformed block record in AST file");
2696  return Failure;
2697  }
2698  break;
2699  }
2700  continue;
2701 
2702  case llvm::BitstreamEntry::Record:
2703  // The interesting case.
2704  break;
2705  }
2706 
2707  // Read and process a record.
2708  Record.clear();
2709  StringRef Blob;
2710  auto RecordType =
2711  (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2712 
2713  // If we're not loading an AST context, we don't care about most records.
2714  if (!ContextObj) {
2715  switch (RecordType) {
2716  case IDENTIFIER_TABLE:
2717  case IDENTIFIER_OFFSET:
2719  case STATISTICS:
2720  case PP_CONDITIONAL_STACK:
2721  case PP_COUNTER_VALUE:
2723  case MODULE_OFFSET_MAP:
2726  case PPD_ENTITIES_OFFSETS:
2727  case HEADER_SEARCH_TABLE:
2728  case IMPORTED_MODULES:
2729  case MACRO_OFFSET:
2730  break;
2731  default:
2732  continue;
2733  }
2734  }
2735 
2736  switch (RecordType) {
2737  default: // Default behavior: ignore.
2738  break;
2739 
2740  case TYPE_OFFSET: {
2741  if (F.LocalNumTypes != 0) {
2742  Error("duplicate TYPE_OFFSET record in AST file");
2743  return Failure;
2744  }
2745  F.TypeOffsets = (const uint32_t *)Blob.data();
2746  F.LocalNumTypes = Record[0];
2747  unsigned LocalBaseTypeIndex = Record[1];
2748  F.BaseTypeIndex = getTotalNumTypes();
2749 
2750  if (F.LocalNumTypes > 0) {
2751  // Introduce the global -> local mapping for types within this module.
2752  GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2753 
2754  // Introduce the local -> global mapping for types within this module.
2756  std::make_pair(LocalBaseTypeIndex,
2757  F.BaseTypeIndex - LocalBaseTypeIndex));
2758 
2759  TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2760  }
2761  break;
2762  }
2763 
2764  case DECL_OFFSET: {
2765  if (F.LocalNumDecls != 0) {
2766  Error("duplicate DECL_OFFSET record in AST file");
2767  return Failure;
2768  }
2769  F.DeclOffsets = (const DeclOffset *)Blob.data();
2770  F.LocalNumDecls = Record[0];
2771  unsigned LocalBaseDeclID = Record[1];
2772  F.BaseDeclID = getTotalNumDecls();
2773 
2774  if (F.LocalNumDecls > 0) {
2775  // Introduce the global -> local mapping for declarations within this
2776  // module.
2777  GlobalDeclMap.insert(
2778  std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2779 
2780  // Introduce the local -> global mapping for declarations within this
2781  // module.
2783  std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2784 
2785  // Introduce the global -> local mapping for declarations within this
2786  // module.
2787  F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2788 
2789  DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2790  }
2791  break;
2792  }
2793 
2794  case TU_UPDATE_LEXICAL: {
2795  DeclContext *TU = ContextObj->getTranslationUnitDecl();
2796  LexicalContents Contents(
2797  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2798  Blob.data()),
2799  static_cast<unsigned int>(Blob.size() / 4));
2800  TULexicalDecls.push_back(std::make_pair(&F, Contents));
2801  TU->setHasExternalLexicalStorage(true);
2802  break;
2803  }
2804 
2805  case UPDATE_VISIBLE: {
2806  unsigned Idx = 0;
2807  serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2808  auto *Data = (const unsigned char*)Blob.data();
2809  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2810  // If we've already loaded the decl, perform the updates when we finish
2811  // loading this block.
2812  if (Decl *D = GetExistingDecl(ID))
2813  PendingUpdateRecords.push_back(
2814  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2815  break;
2816  }
2817 
2818  case IDENTIFIER_TABLE:
2819  F.IdentifierTableData = Blob.data();
2820  if (Record[0]) {
2822  (const unsigned char *)F.IdentifierTableData + Record[0],
2823  (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2824  (const unsigned char *)F.IdentifierTableData,
2825  ASTIdentifierLookupTrait(*this, F));
2826 
2827  PP.getIdentifierTable().setExternalIdentifierLookup(this);
2828  }
2829  break;
2830 
2831  case IDENTIFIER_OFFSET: {
2832  if (F.LocalNumIdentifiers != 0) {
2833  Error("duplicate IDENTIFIER_OFFSET record in AST file");
2834  return Failure;
2835  }
2836  F.IdentifierOffsets = (const uint32_t *)Blob.data();
2837  F.LocalNumIdentifiers = Record[0];
2838  unsigned LocalBaseIdentifierID = Record[1];
2839  F.BaseIdentifierID = getTotalNumIdentifiers();
2840 
2841  if (F.LocalNumIdentifiers > 0) {
2842  // Introduce the global -> local mapping for identifiers within this
2843  // module.
2844  GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2845  &F));
2846 
2847  // Introduce the local -> global mapping for identifiers within this
2848  // module.
2850  std::make_pair(LocalBaseIdentifierID,
2851  F.BaseIdentifierID - LocalBaseIdentifierID));
2852 
2853  IdentifiersLoaded.resize(IdentifiersLoaded.size()
2854  + F.LocalNumIdentifiers);
2855  }
2856  break;
2857  }
2858 
2860  F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2861  break;
2862 
2864  // FIXME: Skip reading this record if our ASTConsumer doesn't care
2865  // about "interesting" decls (for instance, if we're building a module).
2866  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2867  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2868  break;
2869 
2870  case MODULAR_CODEGEN_DECLS:
2871  // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2872  // them (ie: if we're not codegenerating this module).
2873  if (F.Kind == MK_MainFile)
2874  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2875  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2876  break;
2877 
2878  case SPECIAL_TYPES:
2879  if (SpecialTypes.empty()) {
2880  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2881  SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2882  break;
2883  }
2884 
2885  if (SpecialTypes.size() != Record.size()) {
2886  Error("invalid special-types record");
2887  return Failure;
2888  }
2889 
2890  for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2891  serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2892  if (!SpecialTypes[I])
2893  SpecialTypes[I] = ID;
2894  // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2895  // merge step?
2896  }
2897  break;
2898 
2899  case STATISTICS:
2900  TotalNumStatements += Record[0];
2901  TotalNumMacros += Record[1];
2902  TotalLexicalDeclContexts += Record[2];
2903  TotalVisibleDeclContexts += Record[3];
2904  break;
2905 
2907  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2908  UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2909  break;
2910 
2911  case DELEGATING_CTORS:
2912  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2913  DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2914  break;
2915 
2917  if (Record.size() % 4 != 0) {
2918  Error("invalid weak identifiers record");
2919  return Failure;
2920  }
2921 
2922  // FIXME: Ignore weak undeclared identifiers from non-original PCH
2923  // files. This isn't the way to do it :)
2924  WeakUndeclaredIdentifiers.clear();
2925 
2926  // Translate the weak, undeclared identifiers into global IDs.
2927  for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2928  WeakUndeclaredIdentifiers.push_back(
2929  getGlobalIdentifierID(F, Record[I++]));
2930  WeakUndeclaredIdentifiers.push_back(
2931  getGlobalIdentifierID(F, Record[I++]));
2932  WeakUndeclaredIdentifiers.push_back(
2933  ReadSourceLocation(F, Record, I).getRawEncoding());
2934  WeakUndeclaredIdentifiers.push_back(Record[I++]);
2935  }
2936  break;
2937 
2938  case SELECTOR_OFFSETS: {
2939  F.SelectorOffsets = (const uint32_t *)Blob.data();
2940  F.LocalNumSelectors = Record[0];
2941  unsigned LocalBaseSelectorID = Record[1];
2942  F.BaseSelectorID = getTotalNumSelectors();
2943 
2944  if (F.LocalNumSelectors > 0) {
2945  // Introduce the global -> local mapping for selectors within this
2946  // module.
2947  GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2948 
2949  // Introduce the local -> global mapping for selectors within this
2950  // module.
2952  std::make_pair(LocalBaseSelectorID,
2953  F.BaseSelectorID - LocalBaseSelectorID));
2954 
2955  SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2956  }
2957  break;
2958  }
2959 
2960  case METHOD_POOL:
2961  F.SelectorLookupTableData = (const unsigned char *)Blob.data();
2962  if (Record[0])
2965  F.SelectorLookupTableData + Record[0],
2967  ASTSelectorLookupTrait(*this, F));
2968  TotalNumMethodPoolEntries += Record[1];
2969  break;
2970 
2972  if (!Record.empty()) {
2973  for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2974  ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2975  Record[Idx++]));
2976  ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2977  getRawEncoding());
2978  }
2979  }
2980  break;
2981 
2982  case PP_CONDITIONAL_STACK:
2983  if (!Record.empty()) {
2984  SmallVector<PPConditionalInfo, 4> ConditionalStack;
2985  for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2986  auto Loc = ReadSourceLocation(F, Record, Idx);
2987  bool WasSkipping = Record[Idx++];
2988  bool FoundNonSkip = Record[Idx++];
2989  bool FoundElse = Record[Idx++];
2990  ConditionalStack.push_back(
2991  {Loc, WasSkipping, FoundNonSkip, FoundElse});
2992  }
2993  PP.setReplayablePreambleConditionalStack(ConditionalStack);
2994  }
2995  break;
2996 
2997  case PP_COUNTER_VALUE:
2998  if (!Record.empty() && Listener)
2999  Listener->ReadCounter(F, Record[0]);
3000  break;
3001 
3002  case FILE_SORTED_DECLS:
3003  F.FileSortedDecls = (const DeclID *)Blob.data();
3004  F.NumFileSortedDecls = Record[0];
3005  break;
3006 
3007  case SOURCE_LOCATION_OFFSETS: {
3008  F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3009  F.LocalNumSLocEntries = Record[0];
3010  unsigned SLocSpaceSize = Record[1];
3011  std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3012  SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3013  SLocSpaceSize);
3014  if (!F.SLocEntryBaseID) {
3015  Error("ran out of source locations");
3016  break;
3017  }
3018  // Make our entry in the range map. BaseID is negative and growing, so
3019  // we invert it. Because we invert it, though, we need the other end of
3020  // the range.
3021  unsigned RangeStart =
3023  GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3025 
3026  // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3027  assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3028  GlobalSLocOffsetMap.insert(
3029  std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3030  - SLocSpaceSize,&F));
3031 
3032  // Initialize the remapping table.
3033  // Invalid stays invalid.
3034  F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3035  // This module. Base was 2 when being compiled.
3036  F.SLocRemap.insertOrReplace(std::make_pair(2U,
3037  static_cast<int>(F.SLocEntryBaseOffset - 2)));
3038 
3039  TotalNumSLocEntries += F.LocalNumSLocEntries;
3040  break;
3041  }
3042 
3043  case MODULE_OFFSET_MAP:
3044  F.ModuleOffsetMap = Blob;
3045  break;
3046 
3048  if (ParseLineTable(F, Record))
3049  return Failure;
3050  break;
3051 
3052  case SOURCE_LOCATION_PRELOADS: {
3053  // Need to transform from the local view (1-based IDs) to the global view,
3054  // which is based off F.SLocEntryBaseID.
3055  if (!F.PreloadSLocEntries.empty()) {
3056  Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3057  return Failure;
3058  }
3059 
3060  F.PreloadSLocEntries.swap(Record);
3061  break;
3062  }
3063 
3064  case EXT_VECTOR_DECLS:
3065  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3066  ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3067  break;
3068 
3069  case VTABLE_USES:
3070  if (Record.size() % 3 != 0) {
3071  Error("Invalid VTABLE_USES record");
3072  return Failure;
3073  }
3074 
3075  // Later tables overwrite earlier ones.
3076  // FIXME: Modules will have some trouble with this. This is clearly not
3077  // the right way to do this.
3078  VTableUses.clear();
3079 
3080  for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3081  VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3082  VTableUses.push_back(
3083  ReadSourceLocation(F, Record, Idx).getRawEncoding());
3084  VTableUses.push_back(Record[Idx++]);
3085  }
3086  break;
3087 
3089  if (PendingInstantiations.size() % 2 != 0) {
3090  Error("Invalid existing PendingInstantiations");
3091  return Failure;
3092  }
3093 
3094  if (Record.size() % 2 != 0) {
3095  Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3096  return Failure;
3097  }
3098 
3099  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3100  PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3101  PendingInstantiations.push_back(
3102  ReadSourceLocation(F, Record, I).getRawEncoding());
3103  }
3104  break;
3105 
3106  case SEMA_DECL_REFS:
3107  if (Record.size() != 3) {
3108  Error("Invalid SEMA_DECL_REFS block");
3109  return Failure;
3110  }
3111  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3112  SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3113  break;
3114 
3115  case PPD_ENTITIES_OFFSETS: {
3116  F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3117  assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3118  F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3119 
3120  unsigned LocalBasePreprocessedEntityID = Record[0];
3121 
3122  unsigned StartingID;
3123  if (!PP.getPreprocessingRecord())
3124  PP.createPreprocessingRecord();
3125  if (!PP.getPreprocessingRecord()->getExternalSource())
3126  PP.getPreprocessingRecord()->SetExternalSource(*this);
3127  StartingID
3128  = PP.getPreprocessingRecord()
3129  ->allocateLoadedEntities(F.NumPreprocessedEntities);
3130  F.BasePreprocessedEntityID = StartingID;
3131 
3132  if (F.NumPreprocessedEntities > 0) {
3133  // Introduce the global -> local mapping for preprocessed entities in
3134  // this module.
3135  GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3136 
3137  // Introduce the local -> global mapping for preprocessed entities in
3138  // this module.
3140  std::make_pair(LocalBasePreprocessedEntityID,
3141  F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3142  }
3143 
3144  break;
3145  }
3146 
3147  case DECL_UPDATE_OFFSETS: {
3148  if (Record.size() % 2 != 0) {
3149  Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3150  return Failure;
3151  }
3152  for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3153  GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3154  DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3155 
3156  // If we've already loaded the decl, perform the updates when we finish
3157  // loading this block.
3158  if (Decl *D = GetExistingDecl(ID))
3159  PendingUpdateRecords.push_back(
3160  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3161  }
3162  break;
3163  }
3164 
3165  case OBJC_CATEGORIES_MAP: {
3166  if (F.LocalNumObjCCategoriesInMap != 0) {
3167  Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3168  return Failure;
3169  }
3170 
3171  F.LocalNumObjCCategoriesInMap = Record[0];
3172  F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3173  break;
3174  }
3175 
3176  case OBJC_CATEGORIES:
3177  F.ObjCCategories.swap(Record);
3178  break;
3179 
3181  // Later tables overwrite earlier ones.
3182  // FIXME: Modules will have trouble with this.
3183  CUDASpecialDeclRefs.clear();
3184  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3185  CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3186  break;
3187 
3188  case HEADER_SEARCH_TABLE: {
3189  F.HeaderFileInfoTableData = Blob.data();
3190  F.LocalNumHeaderFileInfos = Record[1];
3191  if (Record[0]) {
3194  (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3195  (const unsigned char *)F.HeaderFileInfoTableData,
3196  HeaderFileInfoTrait(*this, F,
3197  &PP.getHeaderSearchInfo(),
3198  Blob.data() + Record[2]));
3199 
3200  PP.getHeaderSearchInfo().SetExternalSource(this);
3201  if (!PP.getHeaderSearchInfo().getExternalLookup())
3202  PP.getHeaderSearchInfo().SetExternalLookup(this);
3203  }
3204  break;
3205  }
3206 
3207  case FP_PRAGMA_OPTIONS:
3208  // Later tables overwrite earlier ones.
3209  FPPragmaOptions.swap(Record);
3210  break;
3211 
3212  case OPENCL_EXTENSIONS:
3213  for (unsigned I = 0, E = Record.size(); I != E; ) {
3214  auto Name = ReadString(Record, I);
3215  auto &Opt = OpenCLExtensions.OptMap[Name];
3216  Opt.Supported = Record[I++] != 0;
3217  Opt.Enabled = Record[I++] != 0;
3218  Opt.Avail = Record[I++];
3219  Opt.Core = Record[I++];
3220  }
3221  break;
3222 
3224  for (unsigned I = 0, E = Record.size(); I != E;) {
3225  auto TypeID = static_cast<::TypeID>(Record[I++]);
3226  auto *Type = GetType(TypeID).getTypePtr();
3227  auto NumExt = static_cast<unsigned>(Record[I++]);
3228  for (unsigned II = 0; II != NumExt; ++II) {
3229  auto Ext = ReadString(Record, I);
3230  OpenCLTypeExtMap[Type].insert(Ext);
3231  }
3232  }
3233  break;
3234 
3236  for (unsigned I = 0, E = Record.size(); I != E;) {
3237  auto DeclID = static_cast<::DeclID>(Record[I++]);
3238  auto *Decl = GetDecl(DeclID);
3239  auto NumExt = static_cast<unsigned>(Record[I++]);
3240  for (unsigned II = 0; II != NumExt; ++II) {
3241  auto Ext = ReadString(Record, I);
3242  OpenCLDeclExtMap[Decl].insert(Ext);
3243  }
3244  }
3245  break;
3246 
3247  case TENTATIVE_DEFINITIONS:
3248  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3249  TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3250  break;
3251 
3252  case KNOWN_NAMESPACES:
3253  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3254  KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3255  break;
3256 
3257  case UNDEFINED_BUT_USED:
3258  if (UndefinedButUsed.size() % 2 != 0) {
3259  Error("Invalid existing UndefinedButUsed");
3260  return Failure;
3261  }
3262 
3263  if (Record.size() % 2 != 0) {
3264  Error("invalid undefined-but-used record");
3265  return Failure;
3266  }
3267  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3268  UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3269  UndefinedButUsed.push_back(
3270  ReadSourceLocation(F, Record, I).getRawEncoding());
3271  }
3272  break;
3274  for (unsigned I = 0, N = Record.size(); I != N;) {
3275  DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3276  const uint64_t Count = Record[I++];
3277  DelayedDeleteExprs.push_back(Count);
3278  for (uint64_t C = 0; C < Count; ++C) {
3279  DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3280  bool IsArrayForm = Record[I++] == 1;
3281  DelayedDeleteExprs.push_back(IsArrayForm);
3282  }
3283  }
3284  break;
3285 
3286  case IMPORTED_MODULES: {
3287  if (!F.isModule()) {
3288  // If we aren't loading a module (which has its own exports), make
3289  // all of the imported modules visible.
3290  // FIXME: Deal with macros-only imports.
3291  for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3292  unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3293  SourceLocation Loc = ReadSourceLocation(F, Record, I);
3294  if (GlobalID) {
3295  ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3296  if (DeserializationListener)
3297  DeserializationListener->ModuleImportRead(GlobalID, Loc);
3298  }
3299  }
3300  }
3301  break;
3302  }
3303 
3304  case MACRO_OFFSET: {
3305  if (F.LocalNumMacros != 0) {
3306  Error("duplicate MACRO_OFFSET record in AST file");
3307  return Failure;
3308  }
3309  F.MacroOffsets = (const uint32_t *)Blob.data();
3310  F.LocalNumMacros = Record[0];
3311  unsigned LocalBaseMacroID = Record[1];
3312  F.BaseMacroID = getTotalNumMacros();
3313 
3314  if (F.LocalNumMacros > 0) {
3315  // Introduce the global -> local mapping for macros within this module.
3316  GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3317 
3318  // Introduce the local -> global mapping for macros within this module.
3320  std::make_pair(LocalBaseMacroID,
3321  F.BaseMacroID - LocalBaseMacroID));
3322 
3323  MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3324  }
3325  break;
3326  }
3327 
3328  case LATE_PARSED_TEMPLATE: {
3329  LateParsedTemplates.append(Record.begin(), Record.end());
3330  break;
3331  }
3332 
3334  if (Record.size() != 1) {
3335  Error("invalid pragma optimize record");
3336  return Failure;
3337  }
3338  OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3339  break;
3340 
3342  if (Record.size() != 1) {
3343  Error("invalid pragma ms_struct record");
3344  return Failure;
3345  }
3346  PragmaMSStructState = Record[0];
3347  break;
3348 
3350  if (Record.size() != 2) {
3351  Error("invalid pragma ms_struct record");
3352  return Failure;
3353  }
3354  PragmaMSPointersToMembersState = Record[0];
3355  PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3356  break;
3357 
3359  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3360  UnusedLocalTypedefNameCandidates.push_back(
3361  getGlobalDeclID(F, Record[I]));
3362  break;
3363 
3365  if (Record.size() != 1) {
3366  Error("invalid cuda pragma options record");
3367  return Failure;
3368  }
3369  ForceCUDAHostDeviceDepth = Record[0];
3370  break;
3371 
3372  case PACK_PRAGMA_OPTIONS: {
3373  if (Record.size() < 3) {
3374  Error("invalid pragma pack record");
3375  return Failure;
3376  }
3377  PragmaPackCurrentValue = Record[0];
3378  PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3379  unsigned NumStackEntries = Record[2];
3380  unsigned Idx = 3;
3381  // Reset the stack when importing a new module.
3382  PragmaPackStack.clear();
3383  for (unsigned I = 0; I < NumStackEntries; ++I) {
3384  PragmaPackStackEntry Entry;
3385  Entry.Value = Record[Idx++];
3386  Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3387  PragmaPackStrings.push_back(ReadString(Record, Idx));
3388  Entry.SlotLabel = PragmaPackStrings.back();
3389  PragmaPackStack.push_back(Entry);
3390  }
3391  break;
3392  }
3393  }
3394  }
3395 }
3396 
3397 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3398  assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3399 
3400  // Additional remapping information.
3401  const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3402  const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3403  F.ModuleOffsetMap = StringRef();
3404 
3405  // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3406  if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3407  F.SLocRemap.insert(std::make_pair(0U, 0));
3408  F.SLocRemap.insert(std::make_pair(2U, 1));
3409  }
3410 
3411  // Continuous range maps we may be updating in our module.
3413  RemapBuilder;
3414  RemapBuilder SLocRemap(F.SLocRemap);
3415  RemapBuilder IdentifierRemap(F.IdentifierRemap);
3416  RemapBuilder MacroRemap(F.MacroRemap);
3417  RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3418  RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3419  RemapBuilder SelectorRemap(F.SelectorRemap);
3420  RemapBuilder DeclRemap(F.DeclRemap);
3421  RemapBuilder TypeRemap(F.TypeRemap);
3422 
3423  while (Data < DataEnd) {
3424  // FIXME: Looking up dependency modules by filename is horrible.
3425  using namespace llvm::support;
3426  uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3427  StringRef Name = StringRef((const char*)Data, Len);
3428  Data += Len;
3429  ModuleFile *OM = ModuleMgr.lookup(Name);
3430  if (!OM) {
3431  std::string Msg =
3432  "SourceLocation remap refers to unknown module, cannot find ";
3433  Msg.append(Name);
3434  Error(Msg);
3435  return;
3436  }
3437 
3438  uint32_t SLocOffset =
3439  endian::readNext<uint32_t, little, unaligned>(Data);
3440  uint32_t IdentifierIDOffset =
3441  endian::readNext<uint32_t, little, unaligned>(Data);
3442  uint32_t MacroIDOffset =
3443  endian::readNext<uint32_t, little, unaligned>(Data);
3444  uint32_t PreprocessedEntityIDOffset =
3445  endian::readNext<uint32_t, little, unaligned>(Data);
3446  uint32_t SubmoduleIDOffset =
3447  endian::readNext<uint32_t, little, unaligned>(Data);
3448  uint32_t SelectorIDOffset =
3449  endian::readNext<uint32_t, little, unaligned>(Data);
3450  uint32_t DeclIDOffset =
3451  endian::readNext<uint32_t, little, unaligned>(Data);
3452  uint32_t TypeIndexOffset =
3453  endian::readNext<uint32_t, little, unaligned>(Data);
3454 
3456 
3457  auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3458  RemapBuilder &Remap) {
3459  if (Offset != None)
3460  Remap.insert(std::make_pair(Offset,
3461  static_cast<int>(BaseOffset - Offset)));
3462  };
3463  mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3464  mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3465  mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3466  mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3467  PreprocessedEntityRemap);
3468  mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3469  mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3470  mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3471  mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3472 
3473  // Global -> local mappings.
3474  F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3475  }
3476 }
3477 
3479 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3480  const ModuleFile *ImportedBy,
3481  unsigned ClientLoadCapabilities) {
3482  unsigned Idx = 0;
3483  F.ModuleMapPath = ReadPath(F, Record, Idx);
3484 
3485  // Try to resolve ModuleName in the current header search context and
3486  // verify that it is found in the same module map file as we saved. If the
3487  // top-level AST file is a main file, skip this check because there is no
3488  // usable header search context.
3489  assert(!F.ModuleName.empty() &&
3490  "MODULE_NAME should come before MODULE_MAP_FILE");
3491  if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3492  // An implicitly-loaded module file should have its module listed in some
3493  // module map file that we've already loaded.
3494  Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3495  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3496  const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3497  if (!ModMap) {
3498  assert(ImportedBy && "top-level import should be verified");
3499  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3500  if (auto *ASTFE = M ? M->getASTFile() : nullptr)
3501  // This module was defined by an imported (explicit) module.
3502  Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3503  << ASTFE->getName();
3504  else
3505  // This module was built with a different module map.
3506  Diag(diag::err_imported_module_not_found)
3507  << F.ModuleName << F.FileName << ImportedBy->FileName
3508  << F.ModuleMapPath;
3509  }
3510  return OutOfDate;
3511  }
3512 
3513  assert(M->Name == F.ModuleName && "found module with different name");
3514 
3515  // Check the primary module map file.
3516  const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3517  if (StoredModMap == nullptr || StoredModMap != ModMap) {
3518  assert(ModMap && "found module is missing module map file");
3519  assert(ImportedBy && "top-level import should be verified");
3520  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3521  Diag(diag::err_imported_module_modmap_changed)
3522  << F.ModuleName << ImportedBy->FileName
3523  << ModMap->getName() << F.ModuleMapPath;
3524  return OutOfDate;
3525  }
3526 
3527  llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3528  for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3529  // FIXME: we should use input files rather than storing names.
3530  std::string Filename = ReadPath(F, Record, Idx);
3531  const FileEntry *F =
3532  FileMgr.getFile(Filename, false, false);
3533  if (F == nullptr) {
3534  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3535  Error("could not find file '" + Filename +"' referenced by AST file");
3536  return OutOfDate;
3537  }
3538  AdditionalStoredMaps.insert(F);
3539  }
3540 
3541  // Check any additional module map files (e.g. module.private.modulemap)
3542  // that are not in the pcm.
3543  if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3544  for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3545  // Remove files that match
3546  // Note: SmallPtrSet::erase is really remove
3547  if (!AdditionalStoredMaps.erase(ModMap)) {
3548  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3549  Diag(diag::err_module_different_modmap)
3550  << F.ModuleName << /*new*/0 << ModMap->getName();
3551  return OutOfDate;
3552  }
3553  }
3554  }
3555 
3556  // Check any additional module map files that are in the pcm, but not
3557  // found in header search. Cases that match are already removed.
3558  for (const FileEntry *ModMap : AdditionalStoredMaps) {
3559  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3560  Diag(diag::err_module_different_modmap)
3561  << F.ModuleName << /*not new*/1 << ModMap->getName();
3562  return OutOfDate;
3563  }
3564  }
3565 
3566  if (Listener)
3567  Listener->ReadModuleMapFile(F.ModuleMapPath);
3568  return Success;
3569 }
3570 
3571 
3572 /// \brief Move the given method to the back of the global list of methods.
3574  // Find the entry for this selector in the method pool.
3575  Sema::GlobalMethodPool::iterator Known
3576  = S.MethodPool.find(Method->getSelector());
3577  if (Known == S.MethodPool.end())
3578  return;
3579 
3580  // Retrieve the appropriate method list.
3581  ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3582  : Known->second.second;
3583  bool Found = false;
3584  for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3585  if (!Found) {
3586  if (List->getMethod() == Method) {
3587  Found = true;
3588  } else {
3589  // Keep searching.
3590  continue;
3591  }
3592  }
3593 
3594  if (List->getNext())
3595  List->setMethod(List->getNext()->getMethod());
3596  else
3597  List->setMethod(Method);
3598  }
3599 }
3600 
3602  assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3603  for (Decl *D : Names) {
3604  bool wasHidden = D->isHidden();
3605  D->setVisibleDespiteOwningModule();
3606 
3607  if (wasHidden && SemaObj) {
3608  if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3609  moveMethodToBackOfGlobalList(*SemaObj, Method);
3610  }
3611  }
3612  }
3613 }
3614 
3616  Module::NameVisibilityKind NameVisibility,
3617  SourceLocation ImportLoc) {
3618  llvm::SmallPtrSet<Module *, 4> Visited;
3620  Stack.push_back(Mod);
3621  while (!Stack.empty()) {
3622  Mod = Stack.pop_back_val();
3623 
3624  if (NameVisibility <= Mod->NameVisibility) {
3625  // This module already has this level of visibility (or greater), so
3626  // there is nothing more to do.
3627  continue;
3628  }
3629 
3630  if (!Mod->isAvailable()) {
3631  // Modules that aren't available cannot be made visible.
3632  continue;
3633  }
3634 
3635  // Update the module's name visibility.
3636  Mod->NameVisibility = NameVisibility;
3637 
3638  // If we've already deserialized any names from this module,
3639  // mark them as visible.
3640  HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3641  if (Hidden != HiddenNamesMap.end()) {
3642  auto HiddenNames = std::move(*Hidden);
3643  HiddenNamesMap.erase(Hidden);
3644  makeNamesVisible(HiddenNames.second, HiddenNames.first);
3645  assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3646  "making names visible added hidden names");
3647  }
3648 
3649  // Push any exported modules onto the stack to be marked as visible.
3650  SmallVector<Module *, 16> Exports;
3651  Mod->getExportedModules(Exports);
3653  I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3654  Module *Exported = *I;
3655  if (Visited.insert(Exported).second)
3656  Stack.push_back(Exported);
3657  }
3658  }
3659 }
3660 
3661 /// We've merged the definition \p MergedDef into the existing definition
3662 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3663 /// visible.
3665  NamedDecl *MergedDef) {
3666  // FIXME: This doesn't correctly handle the case where MergedDef is visible
3667  // in modules other than its owning module. We should instead give the
3668  // ASTContext a list of merged definitions for Def.
3669  if (Def->isHidden()) {
3670  // If MergedDef is visible or becomes visible, make the definition visible.
3671  if (!MergedDef->isHidden())
3673  else if (getContext().getLangOpts().ModulesLocalVisibility) {
3674  getContext().mergeDefinitionIntoModule(
3675  Def, MergedDef->getImportedOwningModule(),
3676  /*NotifyListeners*/ false);
3677  PendingMergedDefinitionsToDeduplicate.insert(Def);
3678  } else {
3679  auto SubmoduleID = MergedDef->getOwningModuleID();
3680  assert(SubmoduleID && "hidden definition in no module");
3681  HiddenNamesMap[getSubmodule(SubmoduleID)].push_back(Def);
3682  }
3683  }
3684 }
3685 
3687  if (GlobalIndex)
3688  return false;
3689 
3690  if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3691  !PP.getLangOpts().Modules)
3692  return true;
3693 
3694  // Try to load the global index.
3695  TriedLoadingGlobalIndex = true;
3696  StringRef ModuleCachePath
3697  = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3698  std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3699  = GlobalModuleIndex::readIndex(ModuleCachePath);
3700  if (!Result.first)
3701  return true;
3702 
3703  GlobalIndex.reset(Result.first);
3704  ModuleMgr.setGlobalIndex(GlobalIndex.get());
3705  return false;
3706 }
3707 
3709  return PP.getLangOpts().Modules && UseGlobalIndex &&
3710  !hasGlobalIndex() && TriedLoadingGlobalIndex;
3711 }
3712 
3714  // Overwrite the timestamp file contents so that file's mtime changes.
3715  std::string TimestampFilename = MF.getTimestampFilename();
3716  std::error_code EC;
3717  llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3718  if (EC)
3719  return;
3720  OS << "Timestamp file\n";
3721  OS.close();
3722  OS.clear_error(); // Avoid triggering a fatal error.
3723 }
3724 
3725 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3726 /// cursor into the start of the given block ID, returning false on success and
3727 /// true on failure.
3728 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3729  while (true) {
3730  llvm::BitstreamEntry Entry = Cursor.advance();
3731  switch (Entry.Kind) {
3733  case llvm::BitstreamEntry::EndBlock:
3734  return true;
3735 
3736  case llvm::BitstreamEntry::Record:
3737  // Ignore top-level records.
3738  Cursor.skipRecord(Entry.ID);
3739  break;
3740 
3741  case llvm::BitstreamEntry::SubBlock:
3742  if (Entry.ID == BlockID) {
3743  if (Cursor.EnterSubBlock(BlockID))
3744  return true;
3745  // Found it!
3746  return false;
3747  }
3748 
3749  if (Cursor.SkipBlock())
3750  return true;
3751  }
3752  }
3753 }
3754 
3756  ModuleKind Type,
3757  SourceLocation ImportLoc,
3758  unsigned ClientLoadCapabilities,
3761  SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3762 
3763  // Defer any pending actions until we get to the end of reading the AST file.
3764  Deserializing AnASTFile(this);
3765 
3766  // Bump the generation number.
3767  unsigned PreviousGeneration = 0;
3768  if (ContextObj)
3769  PreviousGeneration = incrementGeneration(*ContextObj);
3770 
3771  unsigned NumModules = ModuleMgr.size();
3773  switch (ASTReadResult ReadResult =
3774  ReadASTCore(FileName, Type, ImportLoc,
3775  /*ImportedBy=*/nullptr, Loaded, 0, 0,
3776  ASTFileSignature(), ClientLoadCapabilities)) {
3777  case Failure:
3778  case Missing:
3779  case OutOfDate:
3780  case VersionMismatch:
3781  case ConfigurationMismatch:
3782  case HadErrors: {
3783  llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3784  for (const ImportedModule &IM : Loaded)
3785  LoadedSet.insert(IM.Mod);
3786 
3787  ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3788  PP.getLangOpts().Modules
3789  ? &PP.getHeaderSearchInfo().getModuleMap()
3790  : nullptr);
3791 
3792  // If we find that any modules are unusable, the global index is going
3793  // to be out-of-date. Just remove it.
3794  GlobalIndex.reset();
3795  ModuleMgr.setGlobalIndex(nullptr);
3796  return ReadResult;
3797  }
3798  case Success:
3799  break;
3800  }
3801 
3802  // Here comes stuff that we only do once the entire chain is loaded.
3803 
3804  // Load the AST blocks of all of the modules that we loaded.
3805  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3806  MEnd = Loaded.end();
3807  M != MEnd; ++M) {
3808  ModuleFile &F = *M->Mod;
3809 
3810  // Read the AST block.
3811  if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3812  return Result;
3813 
3814  // Read the extension blocks.
3816  if (ASTReadResult Result = ReadExtensionBlock(F))
3817  return Result;
3818  }
3819 
3820  // Once read, set the ModuleFile bit base offset and update the size in
3821  // bits of all files we've seen.
3822  F.GlobalBitOffset = TotalModulesSizeInBits;
3823  TotalModulesSizeInBits += F.SizeInBits;
3824  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3825 
3826  // Preload SLocEntries.
3827  for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3828  int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3829  // Load it through the SourceManager and don't call ReadSLocEntry()
3830  // directly because the entry may have already been loaded in which case
3831  // calling ReadSLocEntry() directly would trigger an assertion in
3832  // SourceManager.
3833  SourceMgr.getLoadedSLocEntryByID(Index);
3834  }
3835 
3836  // Map the original source file ID into the ID space of the current
3837  // compilation.
3838  if (F.OriginalSourceFileID.isValid()) {
3839  F.OriginalSourceFileID = FileID::get(
3840  F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3841  }
3842 
3843  // Preload all the pending interesting identifiers by marking them out of
3844  // date.
3845  for (auto Offset : F.PreloadIdentifierOffsets) {
3846  const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3848 
3849  ASTIdentifierLookupTrait Trait(*this, F);
3850  auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3851  auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3852  auto &II = PP.getIdentifierTable().getOwn(Key);
3853  II.setOutOfDate(true);
3854 
3855  // Mark this identifier as being from an AST file so that we can track
3856  // whether we need to serialize it.
3857  markIdentifierFromAST(*this, II);
3858 
3859  // Associate the ID with the identifier so that the writer can reuse it.
3860  auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3861  SetIdentifierInfo(ID, &II);
3862  }
3863  }
3864 
3865  // Setup the import locations and notify the module manager that we've
3866  // committed to these module files.
3867  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3868  MEnd = Loaded.end();
3869  M != MEnd; ++M) {
3870  ModuleFile &F = *M->Mod;
3871 
3872  ModuleMgr.moduleFileAccepted(&F);
3873 
3874  // Set the import location.
3875  F.DirectImportLoc = ImportLoc;
3876  // FIXME: We assume that locations from PCH / preamble do not need
3877  // any translation.
3878  if (!M->ImportedBy)
3879  F.ImportLoc = M->ImportLoc;
3880  else
3881  F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3882  }
3883 
3884  if (!PP.getLangOpts().CPlusPlus ||
3885  (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
3886  Type != MK_PrebuiltModule)) {
3887  // Mark all of the identifiers in the identifier table as being out of date,
3888  // so that various accessors know to check the loaded modules when the
3889  // identifier is used.
3890  //
3891  // For C++ modules, we don't need information on many identifiers (just
3892  // those that provide macros or are poisoned), so we mark all of
3893  // the interesting ones via PreloadIdentifierOffsets.
3894  for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3895  IdEnd = PP.getIdentifierTable().end();
3896  Id != IdEnd; ++Id)
3897  Id->second->setOutOfDate(true);
3898  }
3899  // Mark selectors as out of date.
3900  for (auto Sel : SelectorGeneration)
3901  SelectorOutOfDate[Sel.first] = true;
3902 
3903  // Resolve any unresolved module exports.
3904  for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3905  UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3906  SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3907  Module *ResolvedMod = getSubmodule(GlobalID);
3908 
3909  switch (Unresolved.Kind) {
3910  case UnresolvedModuleRef::Conflict:
3911  if (ResolvedMod) {
3912  Module::Conflict Conflict;
3913  Conflict.Other = ResolvedMod;
3914  Conflict.Message = Unresolved.String.str();
3915  Unresolved.Mod->Conflicts.push_back(Conflict);
3916  }
3917  continue;
3918 
3919  case UnresolvedModuleRef::Import:
3920  if (ResolvedMod)
3921  Unresolved.Mod->Imports.insert(ResolvedMod);
3922  continue;
3923 
3924  case UnresolvedModuleRef::Export:
3925  if (ResolvedMod || Unresolved.IsWildcard)
3926  Unresolved.Mod->Exports.push_back(
3927  Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3928  continue;
3929  }
3930  }
3931  UnresolvedModuleRefs.clear();
3932 
3933  if (Imported)
3934  Imported->append(ImportedModules.begin(),
3935  ImportedModules.end());
3936 
3937  // FIXME: How do we load the 'use'd modules? They may not be submodules.
3938  // Might be unnecessary as use declarations are only used to build the
3939  // module itself.
3940 
3941  if (ContextObj)
3942  InitializeContext();
3943 
3944  if (SemaObj)
3945  UpdateSema();
3946 
3947  if (DeserializationListener)
3948  DeserializationListener->ReaderInitialized(this);
3949 
3950  ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3951  if (PrimaryModule.OriginalSourceFileID.isValid()) {
3952  // If this AST file is a precompiled preamble, then set the
3953  // preamble file ID of the source manager to the file source file
3954  // from which the preamble was built.
3955  if (Type == MK_Preamble) {
3956  SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3957  } else if (Type == MK_MainFile) {
3958  SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3959  }
3960  }
3961 
3962  // For any Objective-C class definitions we have already loaded, make sure
3963  // that we load any additional categories.
3964  if (ContextObj) {
3965  for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3966  loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3967  ObjCClassesLoaded[I],
3968  PreviousGeneration);
3969  }
3970  }
3971 
3972  if (PP.getHeaderSearchInfo()
3973  .getHeaderSearchOpts()
3974  .ModulesValidateOncePerBuildSession) {
3975  // Now we are certain that the module and all modules it depends on are
3976  // up to date. Create or update timestamp files for modules that are
3977  // located in the module cache (not for PCH files that could be anywhere
3978  // in the filesystem).
3979  for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3980  ImportedModule &M = Loaded[I];
3981  if (M.Mod->Kind == MK_ImplicitModule) {
3982  updateModuleTimestamp(*M.Mod);
3983  }
3984  }
3985  }
3986 
3987  return Success;
3988 }
3989 
3990 static ASTFileSignature readASTFileSignature(StringRef PCH);
3991 
3992 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
3993 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
3994  return Stream.canSkipToPos(4) &&
3995  Stream.Read(8) == 'C' &&
3996  Stream.Read(8) == 'P' &&
3997  Stream.Read(8) == 'C' &&
3998  Stream.Read(8) == 'H';
3999 }
4000 
4002  switch (Kind) {
4003  case MK_PCH:
4004  return 0; // PCH
4005  case MK_ImplicitModule:
4006  case MK_ExplicitModule:
4007  case MK_PrebuiltModule:
4008  return 1; // module
4009  case MK_MainFile:
4010  case MK_Preamble:
4011  return 2; // main source file
4012  }
4013  llvm_unreachable("unknown module kind");
4014 }
4015 
4017 ASTReader::ReadASTCore(StringRef FileName,
4018  ModuleKind Type,
4019  SourceLocation ImportLoc,
4020  ModuleFile *ImportedBy,
4022  off_t ExpectedSize, time_t ExpectedModTime,
4023  ASTFileSignature ExpectedSignature,
4024  unsigned ClientLoadCapabilities) {
4025  ModuleFile *M;
4026  std::string ErrorStr;
4028  = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4029  getGeneration(), ExpectedSize, ExpectedModTime,
4030  ExpectedSignature, readASTFileSignature,
4031  M, ErrorStr);
4032 
4033  switch (AddResult) {
4035  return Success;
4036 
4038  // Load module file below.
4039  break;
4040 
4042  // The module file was missing; if the client can handle that, return
4043  // it.
4044  if (ClientLoadCapabilities & ARR_Missing)
4045  return Missing;
4046 
4047  // Otherwise, return an error.
4048  Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4049  << FileName << !ErrorStr.empty()
4050  << ErrorStr;
4051  return Failure;
4052 
4054  // We couldn't load the module file because it is out-of-date. If the
4055  // client can handle out-of-date, return it.
4056  if (ClientLoadCapabilities & ARR_OutOfDate)
4057  return OutOfDate;
4058 
4059  // Otherwise, return an error.
4060  Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4061  << FileName << !ErrorStr.empty()
4062  << ErrorStr;
4063  return Failure;
4064  }
4065 
4066  assert(M && "Missing module file");
4067 
4068  // FIXME: This seems rather a hack. Should CurrentDir be part of the
4069  // module?
4070  if (FileName != "-") {
4071  CurrentDir = llvm::sys::path::parent_path(FileName);
4072  if (CurrentDir.empty()) CurrentDir = ".";
4073  }
4074 
4075  ModuleFile &F = *M;
4076  BitstreamCursor &Stream = F.Stream;
4077  Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4078  F.SizeInBits = F.Buffer->getBufferSize() * 8;
4079 
4080  // Sniff for the signature.
4081  if (!startsWithASTFileMagic(Stream)) {
4082  Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4083  << FileName;
4084  return Failure;
4085  }
4086 
4087  // This is used for compatibility with older PCH formats.
4088  bool HaveReadControlBlock = false;
4089  while (true) {
4090  llvm::BitstreamEntry Entry = Stream.advance();
4091 
4092  switch (Entry.Kind) {
4094  case llvm::BitstreamEntry::Record:
4095  case llvm::BitstreamEntry::EndBlock:
4096  Error("invalid record at top-level of AST file");
4097  return Failure;
4098 
4099  case llvm::BitstreamEntry::SubBlock:
4100  break;
4101  }
4102 
4103  switch (Entry.ID) {
4104  case CONTROL_BLOCK_ID:
4105  HaveReadControlBlock = true;
4106  switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4107  case Success:
4108  // Check that we didn't try to load a non-module AST file as a module.
4109  //
4110  // FIXME: Should we also perform the converse check? Loading a module as
4111  // a PCH file sort of works, but it's a bit wonky.
4112  if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4113  Type == MK_PrebuiltModule) &&
4114  F.ModuleName.empty()) {
4115  auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4116  if (Result != OutOfDate ||
4117  (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4118  Diag(diag::err_module_file_not_module) << FileName;
4119  return Result;
4120  }
4121  break;
4122 
4123  case Failure: return Failure;
4124  case Missing: return Missing;
4125  case OutOfDate: return OutOfDate;
4126  case VersionMismatch: return VersionMismatch;
4127  case ConfigurationMismatch: return ConfigurationMismatch;
4128  case HadErrors: return HadErrors;
4129  }
4130  break;
4131 
4132  case AST_BLOCK_ID:
4133  if (!HaveReadControlBlock) {
4134  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4135  Diag(diag::err_pch_version_too_old);
4136  return VersionMismatch;
4137  }
4138 
4139  // Record that we've loaded this module.
4140  Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4141  return Success;
4142 
4144  // This block is handled using look-ahead during ReadControlBlock. We
4145  // shouldn't get here!
4146  Error("malformed block record in AST file");
4147  return Failure;
4148 
4149  default:
4150  if (Stream.SkipBlock()) {
4151  Error("malformed block record in AST file");
4152  return Failure;
4153  }
4154  break;
4155  }
4156  }
4157 
4158  return Success;
4159 }
4160 
4162 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4163  unsigned ClientLoadCapabilities) {
4164  const HeaderSearchOptions &HSOpts =
4165  PP.getHeaderSearchInfo().getHeaderSearchOpts();
4166  bool AllowCompatibleConfigurationMismatch =
4168 
4169  ASTReadResult Result = readUnhashedControlBlockImpl(
4170  &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4171  Listener.get(),
4172  WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4173 
4174  // If F was directly imported by another module, it's implicitly validated by
4175  // the importing module.
4176  if (DisableValidation || WasImportedBy ||
4177  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4178  return Success;
4179 
4180  if (Result == Failure) {
4181  Error("malformed block record in AST file");
4182  return Failure;
4183  }
4184 
4185  if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4186  // If this module has already been finalized in the PCMCache, we're stuck
4187  // with it; we can only load a single version of each module.
4188  //
4189  // This can happen when a module is imported in two contexts: in one, as a
4190  // user module; in another, as a system module (due to an import from
4191  // another module marked with the [system] flag). It usually indicates a
4192  // bug in the module map: this module should also be marked with [system].
4193  //
4194  // If -Wno-system-headers (the default), and the first import is as a
4195  // system module, then validation will fail during the as-user import,
4196  // since -Werror flags won't have been validated. However, it's reasonable
4197  // to treat this consistently as a system module.
4198  //
4199  // If -Wsystem-headers, the PCM on disk was built with
4200  // -Wno-system-headers, and the first import is as a user module, then
4201  // validation will fail during the as-system import since the PCM on disk
4202  // doesn't guarantee that -Werror was respected. However, the -Werror
4203  // flags were checked during the initial as-user import.
4204  if (PCMCache.isBufferFinal(F.FileName)) {
4205  Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4206  return Success;
4207  }
4208  }
4209 
4210  return Result;
4211 }
4212 
4213 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4214  ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4215  bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4216  bool ValidateDiagnosticOptions) {
4217  // Initialize a stream.
4218  BitstreamCursor Stream(StreamData);
4219 
4220  // Sniff for the signature.
4221  if (!startsWithASTFileMagic(Stream))
4222  return Failure;
4223 
4224  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4226  return Failure;
4227 
4228  // Read all of the records in the options block.
4229  RecordData Record;
4230  ASTReadResult Result = Success;
4231  while (1) {
4232  llvm::BitstreamEntry Entry = Stream.advance();
4233 
4234  switch (Entry.Kind) {
4236  case llvm::BitstreamEntry::SubBlock:
4237  return Failure;
4238 
4239  case llvm::BitstreamEntry::EndBlock:
4240  return Result;
4241 
4242  case llvm::BitstreamEntry::Record:
4243  // The interesting case.
4244  break;
4245  }
4246 
4247  // Read and process a record.
4248  Record.clear();
4249  switch (
4250  (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4251  case SIGNATURE: {
4252  if (F)
4253  std::copy(Record.begin(), Record.end(), F->Signature.data());
4254  break;
4255  }
4256  case DIAGNOSTIC_OPTIONS: {
4257  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4258  if (Listener && ValidateDiagnosticOptions &&
4259  !AllowCompatibleConfigurationMismatch &&
4260  ParseDiagnosticOptions(Record, Complain, *Listener))
4261  Result = OutOfDate; // Don't return early. Read the signature.
4262  break;
4263  }
4264  case DIAG_PRAGMA_MAPPINGS:
4265  if (!F)
4266  break;
4267  if (F->PragmaDiagMappings.empty())
4268  F->PragmaDiagMappings.swap(Record);
4269  else
4270  F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4271  Record.begin(), Record.end());
4272  break;
4273  }
4274  }
4275 }
4276 
4277 /// Parse a record and blob containing module file extension metadata.
4279  const SmallVectorImpl<uint64_t> &Record,
4280  StringRef Blob,
4281  ModuleFileExtensionMetadata &Metadata) {
4282  if (Record.size() < 4) return true;
4283 
4284  Metadata.MajorVersion = Record[0];
4285  Metadata.MinorVersion = Record[1];
4286 
4287  unsigned BlockNameLen = Record[2];
4288  unsigned UserInfoLen = Record[3];
4289 
4290  if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4291 
4292  Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4293  Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4294  Blob.data() + BlockNameLen + UserInfoLen);
4295  return false;
4296 }
4297 
4298 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4299  BitstreamCursor &Stream = F.Stream;
4300 
4301  RecordData Record;
4302  while (true) {
4303  llvm::BitstreamEntry Entry = Stream.advance();
4304  switch (Entry.Kind) {
4305  case llvm::BitstreamEntry::SubBlock:
4306  if (Stream.SkipBlock())
4307  return Failure;
4308 
4309  continue;
4310 
4311  case llvm::BitstreamEntry::EndBlock:
4312  return Success;
4313 
4315  return HadErrors;
4316 
4317  case llvm::BitstreamEntry::Record:
4318  break;
4319  }
4320 
4321  Record.clear();
4322  StringRef Blob;
4323  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4324  switch (RecCode) {
4325  case EXTENSION_METADATA: {
4326  ModuleFileExtensionMetadata Metadata;
4327  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4328  return Failure;
4329 
4330  // Find a module file extension with this block name.
4331  auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4332  if (Known == ModuleFileExtensions.end()) break;
4333 
4334  // Form a reader.
4335  if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4336  F, Stream)) {
4337  F.ExtensionReaders.push_back(std::move(Reader));
4338  }
4339 
4340  break;
4341  }
4342  }
4343  }
4344 
4345  return Success;
4346 }
4347 
4349  assert(ContextObj && "no context to initialize");
4350  ASTContext &Context = *ContextObj;
4351 
4352  // If there's a listener, notify them that we "read" the translation unit.
4353  if (DeserializationListener)
4354  DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4355  Context.getTranslationUnitDecl());
4356 
4357  // FIXME: Find a better way to deal with collisions between these
4358  // built-in types. Right now, we just ignore the problem.
4359 
4360  // Load the special types.
4361  if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4362  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4363  if (!Context.CFConstantStringTypeDecl)
4364  Context.setCFConstantStringType(GetType(String));
4365  }
4366 
4367  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4368  QualType FileType = GetType(File);
4369  if (FileType.isNull()) {
4370  Error("FILE type is NULL");
4371  return;
4372  }
4373 
4374  if (!Context.FILEDecl) {
4375  if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4376  Context.setFILEDecl(Typedef->getDecl());
4377  else {
4378  const TagType *Tag = FileType->getAs<TagType>();
4379  if (!Tag) {
4380  Error("Invalid FILE type in AST file");
4381  return;
4382  }
4383  Context.setFILEDecl(Tag->getDecl());
4384  }
4385  }
4386  }
4387 
4388  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4389  QualType Jmp_bufType = GetType(Jmp_buf);
4390  if (Jmp_bufType.isNull()) {
4391  Error("jmp_buf type is NULL");
4392  return;
4393  }
4394 
4395  if (!Context.jmp_bufDecl) {
4396  if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4397  Context.setjmp_bufDecl(Typedef->getDecl());
4398  else {
4399  const TagType *Tag = Jmp_bufType->getAs<TagType>();
4400  if (!Tag) {
4401  Error("Invalid jmp_buf type in AST file");
4402  return;
4403  }
4404  Context.setjmp_bufDecl(Tag->getDecl());
4405  }
4406  }
4407  }
4408 
4409  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4410  QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4411  if (Sigjmp_bufType.isNull()) {
4412  Error("sigjmp_buf type is NULL");
4413  return;
4414  }
4415 
4416  if (!Context.sigjmp_bufDecl) {
4417  if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4418  Context.setsigjmp_bufDecl(Typedef->getDecl());
4419  else {
4420  const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4421  assert(Tag && "Invalid sigjmp_buf type in AST file");
4422  Context.setsigjmp_bufDecl(Tag->getDecl());
4423  }
4424  }
4425  }
4426 
4427  if (unsigned ObjCIdRedef
4428  = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4429  if (Context.ObjCIdRedefinitionType.isNull())
4430  Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4431  }
4432 
4433  if (unsigned ObjCClassRedef
4434  = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4435  if (Context.ObjCClassRedefinitionType.isNull())
4436  Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4437  }
4438 
4439  if (unsigned ObjCSelRedef
4440  = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4441  if (Context.ObjCSelRedefinitionType.isNull())
4442  Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4443  }
4444 
4445  if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4446  QualType Ucontext_tType = GetType(Ucontext_t);
4447  if (Ucontext_tType.isNull()) {
4448  Error("ucontext_t type is NULL");
4449  return;
4450  }
4451 
4452  if (!Context.ucontext_tDecl) {
4453  if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4454  Context.setucontext_tDecl(Typedef->getDecl());
4455  else {
4456  const TagType *Tag = Ucontext_tType->getAs<TagType>();
4457  assert(Tag && "Invalid ucontext_t type in AST file");
4458  Context.setucontext_tDecl(Tag->getDecl());
4459  }
4460  }
4461  }
4462  }
4463 
4464  ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4465 
4466  // If there were any CUDA special declarations, deserialize them.
4467  if (!CUDASpecialDeclRefs.empty()) {
4468  assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4469  Context.setcudaConfigureCallDecl(
4470  cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4471  }
4472 
4473  // Re-export any modules that were imported by a non-module AST file.
4474  // FIXME: This does not make macro-only imports visible again.
4475  for (auto &Import : ImportedModules) {
4476  if (Module *Imported = getSubmodule(Import.ID)) {
4477  makeModuleVisible(Imported, Module::AllVisible,
4478  /*ImportLoc=*/Import.ImportLoc);
4479  if (Import.ImportLoc.isValid())
4480  PP.makeModuleVisible(Imported, Import.ImportLoc);
4481  // FIXME: should we tell Sema to make the module visible too?
4482  }
4483  }
4484  ImportedModules.clear();
4485 }
4486 
4488  // Nothing to do for now.
4489 }
4490 
4491 /// \brief Reads and return the signature record from \p PCH's control block, or
4492 /// else returns 0.
4494  BitstreamCursor Stream(PCH);
4495  if (!startsWithASTFileMagic(Stream))
4496  return ASTFileSignature();
4497 
4498  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4500  return ASTFileSignature();
4501 
4502  // Scan for SIGNATURE inside the diagnostic options block.
4503  ASTReader::RecordData Record;
4504  while (true) {
4505  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4506  if (Entry.Kind != llvm::BitstreamEntry::Record)
4507  return ASTFileSignature();
4508 
4509  Record.clear();
4510  StringRef Blob;
4511  if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4512  return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4513  (uint32_t)Record[3], (uint32_t)Record[4]}}};
4514  }
4515 }
4516 
4517 /// \brief Retrieve the name of the original source file name
4518 /// directly from the AST file, without actually loading the AST
4519 /// file.
4521  const std::string &ASTFileName, FileManager &FileMgr,
4522  const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4523  // Open the AST file.
4524  auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4525  if (!Buffer) {
4526  Diags.Report(diag::err_fe_unable_to_read_pch_file)
4527  << ASTFileName << Buffer.getError().message();
4528  return std::string();
4529  }
4530 
4531  // Initialize the stream
4532  BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4533 
4534  // Sniff for the signature.
4535  if (!startsWithASTFileMagic(Stream)) {
4536  Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4537  return std::string();
4538  }
4539 
4540  // Scan for the CONTROL_BLOCK_ID block.
4541  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4542  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4543  return std::string();
4544  }
4545 
4546  // Scan for ORIGINAL_FILE inside the control block.
4547  RecordData Record;
4548  while (true) {
4549  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4550  if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4551  return std::string();
4552 
4553  if (Entry.Kind != llvm::BitstreamEntry::Record) {
4554  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4555  return std::string();
4556  }
4557 
4558  Record.clear();
4559  StringRef Blob;
4560  if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4561  return Blob.str();
4562  }
4563 }
4564 
4565 namespace {
4566 
4567  class SimplePCHValidator : public ASTReaderListener {
4568  const LangOptions &ExistingLangOpts;
4569  const TargetOptions &ExistingTargetOpts;
4570  const PreprocessorOptions &ExistingPPOpts;
4571  std::string ExistingModuleCachePath;
4572  FileManager &FileMgr;
4573 
4574  public:
4575  SimplePCHValidator(const LangOptions &ExistingLangOpts,
4576  const TargetOptions &ExistingTargetOpts,
4577  const PreprocessorOptions &ExistingPPOpts,
4578  StringRef ExistingModuleCachePath,
4579  FileManager &FileMgr)
4580  : ExistingLangOpts(ExistingLangOpts),
4581  ExistingTargetOpts(ExistingTargetOpts),
4582  ExistingPPOpts(ExistingPPOpts),
4583  ExistingModuleCachePath(ExistingModuleCachePath),
4584  FileMgr(FileMgr)
4585  {
4586  }
4587 
4588  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4589  bool AllowCompatibleDifferences) override {
4590  return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4591  AllowCompatibleDifferences);
4592  }
4593 
4594  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4595  bool AllowCompatibleDifferences) override {
4596  return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4597  AllowCompatibleDifferences);
4598  }
4599 
4600  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4601  StringRef SpecificModuleCachePath,
4602  bool Complain) override {
4603  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4604  ExistingModuleCachePath,
4605  nullptr, ExistingLangOpts);
4606  }
4607 
4608  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4609  bool Complain,
4610  std::string &SuggestedPredefines) override {
4611  return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4612  SuggestedPredefines, ExistingLangOpts);
4613  }
4614  };
4615 
4616 } // end anonymous namespace
4617 
4619  StringRef Filename, FileManager &FileMgr,
4620  const PCHContainerReader &PCHContainerRdr,
4621  bool FindModuleFileExtensions,
4622  ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4623  // Open the AST file.
4624  // FIXME: This allows use of the VFS; we do not allow use of the
4625  // VFS when actually loading a module.
4626  auto Buffer = FileMgr.getBufferForFile(Filename);
4627  if (!Buffer) {
4628  return true;
4629  }
4630 
4631  // Initialize the stream
4632  StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4633  BitstreamCursor Stream(Bytes);
4634 
4635  // Sniff for the signature.
4636  if (!startsWithASTFileMagic(Stream))
4637  return true;
4638 
4639  // Scan for the CONTROL_BLOCK_ID block.
4640  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4641  return true;
4642 
4643  bool NeedsInputFiles = Listener.needsInputFileVisitation();
4644  bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4645  bool NeedsImports = Listener.needsImportVisitation();
4646  BitstreamCursor InputFilesCursor;
4647 
4648  RecordData Record;
4649  std::string ModuleDir;
4650  bool DoneWithControlBlock = false;
4651  while (!DoneWithControlBlock) {
4652  llvm::BitstreamEntry Entry = Stream.advance();
4653 
4654  switch (Entry.Kind) {
4655  case llvm::BitstreamEntry::SubBlock: {
4656  switch (Entry.ID) {
4657  case OPTIONS_BLOCK_ID: {
4658  std::string IgnoredSuggestedPredefines;
4659  if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4660  /*AllowCompatibleConfigurationMismatch*/ false,
4661  Listener, IgnoredSuggestedPredefines) != Success)
4662  return true;
4663  break;
4664  }
4665 
4666  case INPUT_FILES_BLOCK_ID:
4667  InputFilesCursor = Stream;
4668  if (Stream.SkipBlock() ||
4669  (NeedsInputFiles &&
4670  ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4671  return true;
4672  break;
4673 
4674  default:
4675  if (Stream.SkipBlock())
4676  return true;
4677  break;
4678  }
4679 
4680  continue;
4681  }
4682 
4683  case llvm::BitstreamEntry::EndBlock:
4684  DoneWithControlBlock = true;
4685  break;
4686 
4688  return true;
4689 
4690  case llvm::BitstreamEntry::Record:
4691  break;
4692  }
4693 
4694  if (DoneWithControlBlock) break;
4695 
4696  Record.clear();
4697  StringRef Blob;
4698  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4699  switch ((ControlRecordTypes)RecCode) {
4700  case METADATA: {
4701  if (Record[0] != VERSION_MAJOR)
4702  return true;
4703 
4704  if (Listener.ReadFullVersionInformation(Blob))
4705  return true;
4706 
4707  break;
4708  }
4709  case MODULE_NAME:
4710  Listener.ReadModuleName(Blob);
4711  break;
4712  case MODULE_DIRECTORY:
4713  ModuleDir = Blob;
4714  break;
4715  case MODULE_MAP_FILE: {
4716  unsigned Idx = 0;
4717  auto Path = ReadString(Record, Idx);
4718  ResolveImportedPath(Path, ModuleDir);
4719  Listener.ReadModuleMapFile(Path);
4720  break;
4721  }
4722  case INPUT_FILE_OFFSETS: {
4723  if (!NeedsInputFiles)
4724  break;
4725 
4726  unsigned NumInputFiles = Record[0];
4727  unsigned NumUserFiles = Record[1];
4728  const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
4729  for (unsigned I = 0; I != NumInputFiles; ++I) {
4730  // Go find this input file.
4731  bool isSystemFile = I >= NumUserFiles;
4732 
4733  if (isSystemFile && !NeedsSystemInputFiles)
4734  break; // the rest are system input files
4735 
4736  BitstreamCursor &Cursor = InputFilesCursor;
4737  SavedStreamPosition SavedPosition(Cursor);
4738  Cursor.JumpToBit(InputFileOffs[I]);
4739 
4740  unsigned Code = Cursor.ReadCode();
4741  RecordData Record;
4742  StringRef Blob;
4743  bool shouldContinue = false;
4744  switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4745  case INPUT_FILE:
4746  bool Overridden = static_cast<bool>(Record[3]);
4747  std::string Filename = Blob;
4748  ResolveImportedPath(Filename, ModuleDir);
4749  shouldContinue = Listener.visitInputFile(
4750  Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4751  break;
4752  }
4753  if (!shouldContinue)
4754  break;
4755  }
4756  break;
4757  }
4758 
4759  case IMPORTS: {
4760  if (!NeedsImports)
4761  break;
4762 
4763  unsigned Idx = 0, N = Record.size();
4764  while (Idx < N) {
4765  // Read information about the AST file.
4766  Idx += 5; // ImportLoc, Size, ModTime, Signature
4767  std::string Filename = ReadString(Record, Idx);
4768  ResolveImportedPath(Filename, ModuleDir);
4769  Listener.visitImport(Filename);
4770  }
4771  break;
4772  }
4773 
4774  default:
4775  // No other validation to perform.
4776  break;
4777  }
4778  }
4779 
4780  // Look for module file extension blocks, if requested.
4781  if (FindModuleFileExtensions) {
4782  BitstreamCursor SavedStream = Stream;
4783  while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4784  bool DoneWithExtensionBlock = false;
4785  while (!DoneWithExtensionBlock) {
4786  llvm::BitstreamEntry Entry = Stream.advance();
4787 
4788  switch (Entry.Kind) {
4789  case llvm::BitstreamEntry::SubBlock:
4790  if (Stream.SkipBlock())
4791  return true;
4792 
4793  continue;
4794 
4795  case llvm::BitstreamEntry::EndBlock:
4796  DoneWithExtensionBlock = true;
4797  continue;
4798 
4800  return true;
4801 
4802  case llvm::BitstreamEntry::Record:
4803  break;
4804  }
4805 
4806  Record.clear();
4807  StringRef Blob;
4808  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4809  switch (RecCode) {
4810  case EXTENSION_METADATA: {
4811  ModuleFileExtensionMetadata Metadata;
4812  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4813  return true;
4814 
4815  Listener.readModuleFileExtension(Metadata);
4816  break;
4817  }
4818  }
4819  }
4820  }
4821  Stream = SavedStream;
4822  }
4823 
4824  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4825  if (readUnhashedControlBlockImpl(
4826  nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4827  /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4828  ValidateDiagnosticOptions) != Success)
4829  return true;
4830 
4831  return false;
4832 }
4833 
4834 bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
4835  const PCHContainerReader &PCHContainerRdr,
4836  const LangOptions &LangOpts,
4837  const TargetOptions &TargetOpts,
4838  const PreprocessorOptions &PPOpts,
4839  StringRef ExistingModuleCachePath) {
4840  SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4841  ExistingModuleCachePath, FileMgr);
4842  return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4843  /*FindModuleFileExtensions=*/false,
4844  validator,
4845  /*ValidateDiagnosticOptions=*/true);
4846 }
4847 
4849 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4850  // Enter the submodule block.
4851  if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4852  Error("malformed submodule block record in AST file");
4853  return Failure;
4854  }
4855 
4856  ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4857  bool First = true;
4858  Module *CurrentModule = nullptr;
4860  RecordData Record;
4861  while (true) {
4862  llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4863 
4864  switch (Entry.Kind) {
4865  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4867  Error("malformed block record in AST file");
4868  return Failure;
4869  case llvm::BitstreamEntry::EndBlock:
4870  return Success;
4871  case llvm::BitstreamEntry::Record:
4872  // The interesting case.
4873  break;
4874  }
4875 
4876  // Read a record.
4877  StringRef Blob;
4878  Record.clear();
4879  auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4880 
4881  if ((Kind == SUBMODULE_METADATA) != First) {
4882  Error("submodule metadata record should be at beginning of block");
4883  return Failure;
4884  }
4885  First = false;
4886 
4887  // Submodule information is only valid if we have a current module.
4888  // FIXME: Should we error on these cases?
4889  if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4891  continue;
4892 
4893  switch (Kind) {
4894  default: // Default behavior: ignore.
4895  break;
4896 
4897  case SUBMODULE_DEFINITION: {
4898  if (Record.size() < 8) {
4899  Error("malformed module definition");
4900  return Failure;
4901  }
4902 
4903  StringRef Name = Blob;
4904  unsigned Idx = 0;
4905  SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4906  SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4907  bool IsFramework = Record[Idx++];
4908  bool IsExplicit = Record[Idx++];
4909  bool IsSystem = Record[Idx++];
4910  bool IsExternC = Record[Idx++];
4911  bool InferSubmodules = Record[Idx++];
4912  bool InferExplicitSubmodules = Record[Idx++];
4913  bool InferExportWildcard = Record[Idx++];
4914  bool ConfigMacrosExhaustive = Record[Idx++];
4915 
4916  Module *ParentModule = nullptr;
4917  if (Parent)
4918  ParentModule = getSubmodule(Parent);
4919 
4920  // Retrieve this (sub)module from the module map, creating it if
4921  // necessary.
4922  CurrentModule =
4923  ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
4924  .first;
4925 
4926  // FIXME: set the definition loc for CurrentModule, or call
4927  // ModMap.setInferredModuleAllowedBy()
4928 
4929  SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4930  if (GlobalIndex >= SubmodulesLoaded.size() ||
4931  SubmodulesLoaded[GlobalIndex]) {
4932  Error("too many submodules");
4933  return Failure;
4934  }
4935 
4936  if (!ParentModule) {
4937  if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4938  if (CurFile != F.File) {
4939  if (!Diags.isDiagnosticInFlight()) {
4940  Diag(diag::err_module_file_conflict)
4941  << CurrentModule->getTopLevelModuleName()
4942  << CurFile->getName()
4943  << F.File->getName();
4944  }
4945  return Failure;
4946  }
4947  }
4948 
4949  CurrentModule->setASTFile(F.File);
4950  CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
4951  }
4952 
4953  CurrentModule->Kind = ModuleKind;
4954  CurrentModule->Signature = F.Signature;
4955  CurrentModule->IsFromModuleFile = true;
4956  CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
4957  CurrentModule->IsExternC = IsExternC;
4958  CurrentModule->InferSubmodules = InferSubmodules;
4959  CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4960  CurrentModule->InferExportWildcard = InferExportWildcard;
4961  CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
4962  if (DeserializationListener)
4963  DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4964 
4965  SubmodulesLoaded[GlobalIndex] = CurrentModule;
4966 
4967  // Clear out data that will be replaced by what is in the module file.
4968  CurrentModule->LinkLibraries.clear();
4969  CurrentModule->ConfigMacros.clear();
4970  CurrentModule->UnresolvedConflicts.clear();
4971  CurrentModule->Conflicts.clear();
4972 
4973  // The module is available unless it's missing a requirement; relevant
4974  // requirements will be (re-)added by SUBMODULE_REQUIRES records.
4975  // Missing headers that were present when the module was built do not
4976  // make it unavailable -- if we got this far, this must be an explicitly
4977  // imported module file.
4978  CurrentModule->Requirements.clear();
4979  CurrentModule->MissingHeaders.clear();
4980  CurrentModule->IsMissingRequirement =
4981  ParentModule && ParentModule->IsMissingRequirement;
4982  CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
4983  break;
4984  }
4985 
4987  std::string Filename = Blob;
4988  ResolveImportedPath(F, Filename);
4989  if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
4990  if (!CurrentModule->getUmbrellaHeader())
4991  ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
4992  else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
4993  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4994  Error("mismatched umbrella headers in submodule");
4995  return OutOfDate;
4996  }
4997  }
4998  break;
4999  }
5000 
5001  case SUBMODULE_HEADER:
5004  // We lazily associate headers with their modules via the HeaderInfo table.
5005  // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5006  // of complete filenames or remove it entirely.
5007  break;
5008 
5011  // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5012  // them here.
5013  break;
5014 
5015  case SUBMODULE_TOPHEADER: {
5016  CurrentModule->addTopHeaderFilename(Blob);
5017  break;
5018  }
5019 
5020  case SUBMODULE_UMBRELLA_DIR: {
5021  std::string Dirname = Blob;
5022  ResolveImportedPath(F, Dirname);
5023  if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5024  if (!CurrentModule->getUmbrellaDir())
5025  ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5026  else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5027  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5028  Error("mismatched umbrella directories in submodule");
5029  return OutOfDate;
5030  }
5031  }
5032  break;
5033  }
5034 
5035  case SUBMODULE_METADATA: {
5036  F.BaseSubmoduleID = getTotalNumSubmodules();
5037  F.LocalNumSubmodules = Record[0];
5038  unsigned LocalBaseSubmoduleID = Record[1];
5039  if (F.LocalNumSubmodules > 0) {
5040  // Introduce the global -> local mapping for submodules within this
5041  // module.
5042  GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5043 
5044  // Introduce the local -> global mapping for submodules within this
5045  // module.
5046  F.SubmoduleRemap.insertOrReplace(
5047  std::make_pair(LocalBaseSubmoduleID,
5048  F.BaseSubmoduleID - LocalBaseSubmoduleID));
5049 
5050  SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5051  }
5052  ModuleKind = (Module::ModuleKind)Record[2];
5053  break;
5054  }
5055 
5056  case SUBMODULE_IMPORTS: {
5057  for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5058  UnresolvedModuleRef Unresolved;
5059  Unresolved.File = &F;
5060  Unresolved.Mod = CurrentModule;
5061  Unresolved.ID = Record[Idx];
5062  Unresolved.Kind = UnresolvedModuleRef::Import;
5063  Unresolved.IsWildcard = false;
5064  UnresolvedModuleRefs.push_back(Unresolved);
5065  }
5066  break;
5067  }
5068 
5069  case SUBMODULE_EXPORTS: {
5070  for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5071  UnresolvedModuleRef Unresolved;
5072  Unresolved.File = &F;
5073  Unresolved.Mod = CurrentModule;
5074  Unresolved.ID = Record[Idx];
5075  Unresolved.Kind = UnresolvedModuleRef::Export;
5076  Unresolved.IsWildcard = Record[Idx + 1];
5077  UnresolvedModuleRefs.push_back(Unresolved);
5078  }
5079 
5080  // Once we've loaded the set of exports, there's no reason to keep
5081  // the parsed, unresolved exports around.
5082  CurrentModule->UnresolvedExports.clear();
5083  break;
5084  }
5085  case SUBMODULE_REQUIRES: {
5086  CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5087  PP.getTargetInfo());
5088  break;
5089  }
5090 
5092  CurrentModule->LinkLibraries.push_back(
5093  Module::LinkLibrary(Blob, Record[0]));
5094  break;
5095 
5097  CurrentModule->ConfigMacros.push_back(Blob.str());
5098  break;
5099 
5100  case SUBMODULE_CONFLICT: {
5101  UnresolvedModuleRef Unresolved;
5102  Unresolved.File = &F;
5103  Unresolved.Mod = CurrentModule;
5104  Unresolved.ID = Record[0];
5105  Unresolved.Kind = UnresolvedModuleRef::Conflict;
5106  Unresolved.IsWildcard = false;
5107  Unresolved.String = Blob;
5108  UnresolvedModuleRefs.push_back(Unresolved);
5109  break;
5110  }
5111 
5113  if (!ContextObj)
5114  break;
5116  for (auto &ID : Record)
5117  Inits.push_back(getGlobalDeclID(F, ID));
5118  ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5119  break;
5120  }
5121  }
5122 }
5123 
5124 /// \brief Parse the record that corresponds to a LangOptions data
5125 /// structure.
5126 ///
5127 /// This routine parses the language options from the AST file and then gives
5128 /// them to the AST listener if one is set.
5129 ///
5130 /// \returns true if the listener deems the file unacceptable, false otherwise.
5131 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5132  bool Complain,
5133  ASTReaderListener &Listener,
5134  bool AllowCompatibleDifferences) {
5135  LangOptions LangOpts;
5136  unsigned Idx = 0;
5137 #define LANGOPT(Name, Bits, Default, Description) \
5138  LangOpts.Name = Record[Idx++];
5139 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5140  LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5141 #include "clang/Basic/LangOptions.def"
5142 #define SANITIZER(NAME, ID) \
5143  LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5144 #include "clang/Basic/Sanitizers.def"
5145 
5146  for (unsigned N = Record[Idx++]; N; --N)
5147  LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5148 
5149  ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5150  VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5151  LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5152 
5153  LangOpts.CurrentModule = ReadString(Record, Idx);
5154 
5155  // Comment options.
5156  for (unsigned N = Record[Idx++]; N; --N) {
5157  LangOpts.CommentOpts.BlockCommandNames.push_back(
5158  ReadString(Record, Idx));
5159  }
5160  LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5161 
5162  // OpenMP offloading options.
5163  for (unsigned N = Record[Idx++]; N; --N) {
5164  LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5165  }
5166 
5167  LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5168 
5169  return Listener.ReadLanguageOptions(LangOpts, Complain,
5170  AllowCompatibleDifferences);
5171 }
5172 
5173 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5174  ASTReaderListener &Listener,
5175  bool AllowCompatibleDifferences) {
5176  unsigned Idx = 0;
5177  TargetOptions TargetOpts;
5178  TargetOpts.Triple = ReadString(Record, Idx);
5179  TargetOpts.CPU = ReadString(Record, Idx);
5180  TargetOpts.ABI = ReadString(Record, Idx);
5181  for (unsigned N = Record[Idx++]; N; --N) {
5182  TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5183  }
5184  for (unsigned N = Record[Idx++]; N; --N) {
5185  TargetOpts.Features.push_back(ReadString(Record, Idx));
5186  }
5187 
5188  return Listener.ReadTargetOptions(TargetOpts, Complain,
5189  AllowCompatibleDifferences);
5190 }
5191 
5192 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5193  ASTReaderListener &Listener) {
5195  unsigned Idx = 0;
5196 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5197 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5198  DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5199 #include "clang/Basic/DiagnosticOptions.def"
5200 
5201  for (unsigned N = Record[Idx++]; N; --N)
5202  DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5203  for (unsigned N = Record[Idx++]; N; --N)
5204  DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5205 
5206  return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5207 }
5208 
5209 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5210  ASTReaderListener &Listener) {
5211  FileSystemOptions FSOpts;
5212  unsigned Idx = 0;
5213  FSOpts.WorkingDir = ReadString(Record, Idx);
5214  return Listener.ReadFileSystemOptions(FSOpts, Complain);
5215 }
5216 
5217 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5218  bool Complain,
5219  ASTReaderListener &Listener) {
5220  HeaderSearchOptions HSOpts;
5221  unsigned Idx = 0;
5222  HSOpts.Sysroot = ReadString(Record, Idx);
5223 
5224  // Include entries.
5225  for (unsigned N = Record[Idx++]; N; --N) {
5226  std::string Path = ReadString(Record, Idx);
5228  = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5229  bool IsFramework = Record[Idx++];
5230  bool IgnoreSysRoot = Record[Idx++];
5231  HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5232  IgnoreSysRoot);
5233  }
5234 
5235  // System header prefixes.
5236  for (unsigned N = Record[Idx++]; N; --N) {
5237  std::string Prefix = ReadString(Record, Idx);
5238  bool IsSystemHeader = Record[Idx++];
5239  HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5240  }
5241 
5242  HSOpts.ResourceDir = ReadString(Record, Idx);
5243  HSOpts.ModuleCachePath = ReadString(Record, Idx);
5244  HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5245  HSOpts.DisableModuleHash = Record[Idx++];
5246  HSOpts.ImplicitModuleMaps = Record[Idx++];
5247  HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5248  HSOpts.UseBuiltinIncludes = Record[Idx++];
5249  HSOpts.UseStandardSystemIncludes = Record[Idx++];
5250  HSOpts.UseStandardCXXIncludes = Record[Idx++];
5251  HSOpts.UseLibcxx = Record[Idx++];
5252  std::string SpecificModuleCachePath = ReadString(Record, Idx);
5253 
5254  return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5255  Complain);
5256 }
5257 
5258 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5259  bool Complain,
5260  ASTReaderListener &Listener,
5261  std::string &SuggestedPredefines) {
5262  PreprocessorOptions PPOpts;
5263  unsigned Idx = 0;
5264 
5265  // Macro definitions/undefs
5266  for (unsigned N = Record[Idx++]; N; --N) {
5267  std::string Macro = ReadString(Record, Idx);
5268  bool IsUndef = Record[Idx++];
5269  PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5270  }
5271 
5272  // Includes
5273  for (unsigned N = Record[Idx++]; N; --N) {
5274  PPOpts.Includes.push_back(ReadString(Record, Idx));
5275  }
5276 
5277  // Macro Includes
5278  for (unsigned N = Record[Idx++]; N; --N) {
5279  PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5280  }
5281 
5282  PPOpts.UsePredefines = Record[Idx++];
5283  PPOpts.DetailedRecord = Record[Idx++];
5284  PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5285  PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
5286  PPOpts.ObjCXXARCStandardLibrary =
5287  static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5288  SuggestedPredefines.clear();
5289  return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5290  SuggestedPredefines);
5291 }
5292 
5293 std::pair<ModuleFile *, unsigned>
5294 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5295  GlobalPreprocessedEntityMapType::iterator
5296  I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5297  assert(I != GlobalPreprocessedEntityMap.end() &&
5298  "Corrupted global preprocessed entity map");
5299  ModuleFile *M = I->second;
5300  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5301  return std::make_pair(M, LocalIndex);
5302 }
5303 
5304 llvm::iterator_range<PreprocessingRecord::iterator>
5305 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5306  if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5307  return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5309 
5310  return llvm::make_range(PreprocessingRecord::iterator(),
5312 }
5313 
5314 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5316  return llvm::make_range(
5317  ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5318  ModuleDeclIterator(this, &Mod,
5319  Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5320 }
5321 
5323  PreprocessedEntityID PPID = Index+1;
5324  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5325  ModuleFile &M = *PPInfo.first;
5326  unsigned LocalIndex = PPInfo.second;
5327  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5328 
5329  if (!PP.getPreprocessingRecord()) {
5330  Error("no preprocessing record");
5331  return nullptr;
5332  }
5333 
5335  M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5336 
5337  llvm::BitstreamEntry Entry =
5338  M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5339  if (Entry.Kind != llvm::BitstreamEntry::Record)
5340  return nullptr;
5341 
5342  // Read the record.
5343  SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5344  TranslateSourceLocation(M, PPOffs.getEnd()));
5345  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5346  StringRef Blob;
5347  RecordData Record;
5350  Entry.ID, Record, &Blob);
5351  switch (RecType) {
5352  case PPD_MACRO_EXPANSION: {
5353  bool isBuiltin = Record[0];
5354  IdentifierInfo *Name = nullptr;
5355  MacroDefinitionRecord *Def = nullptr;
5356  if (isBuiltin)
5357  Name = getLocalIdentifier(M, Record[1]);
5358  else {
5359  PreprocessedEntityID GlobalID =
5360  getGlobalPreprocessedEntityID(M, Record[1]);
5361  Def = cast<MacroDefinitionRecord>(
5362  PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5363  }
5364 
5365  MacroExpansion *ME;
5366  if (isBuiltin)
5367  ME = new (PPRec) MacroExpansion(Name, Range);
5368  else
5369  ME = new (PPRec) MacroExpansion(Def, Range);
5370 
5371  return ME;
5372  }
5373 
5374  case PPD_MACRO_DEFINITION: {
5375  // Decode the identifier info and then check again; if the macro is
5376  // still defined and associated with the identifier,
5377  IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5378  MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5379 
5380  if (DeserializationListener)
5381  DeserializationListener->MacroDefinitionRead(PPID, MD);
5382 
5383  return MD;
5384  }
5385 
5386  case PPD_INCLUSION_DIRECTIVE: {
5387  const char *FullFileNameStart = Blob.data() + Record[0];
5388  StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5389  const FileEntry *File = nullptr;
5390  if (!FullFileName.empty())
5391  File = PP.getFileManager().getFile(FullFileName);
5392 
5393  // FIXME: Stable encoding
5395  = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5396  InclusionDirective *ID
5397  = new (PPRec) InclusionDirective(PPRec, Kind,
5398  StringRef(Blob.data(), Record[0]),
5399  Record[1], Record[3],
5400  File,
5401  Range);
5402  return ID;
5403  }
5404  }
5405 
5406  llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5407 }
5408 
5409 /// \brief \arg SLocMapI points at a chunk of a module that contains no
5410 /// preprocessed entities or the entities it contains are not the ones we are
5411 /// looking for. Find the next module that contains entities and return the ID
5412 /// of the first entry.
5413 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5414  GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5415  ++SLocMapI;
5416  for (GlobalSLocOffsetMapType::const_iterator
5417  EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5418  ModuleFile &M = *SLocMapI->second;
5419  if (M.NumPreprocessedEntities)
5420  return M.BasePreprocessedEntityID;
5421  }
5422 
5423  return getTotalNumPreprocessedEntities();
5424 }
5425 
5426 namespace {
5427 
5428 struct PPEntityComp {
5429  const ASTReader &Reader;
5430  ModuleFile &M;
5431 
5432  PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
5433 
5434  bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5435  SourceLocation LHS = getLoc(L);
5436  SourceLocation RHS = getLoc(R);
5437  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5438  }
5439 
5440  bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5441  SourceLocation LHS = getLoc(L);
5442  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5443  }
5444 
5445  bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5446  SourceLocation RHS = getLoc(R);
5447  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5448  }
5449 
5450  SourceLocation getLoc(const PPEntityOffset &PPE) const {
5451  return Reader.TranslateSourceLocation(M, PPE.getBegin());
5452  }
5453 };
5454 
5455 } // end anonymous namespace
5456 
5457 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5458  bool EndsAfter) const {
5459  if (SourceMgr.isLocalSourceLocation(Loc))
5460  return getTotalNumPreprocessedEntities();
5461 
5462  GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5463  SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5464  assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5465  "Corrupted global sloc offset map");
5466 
5467  if (SLocMapI->second->NumPreprocessedEntities == 0)
5468  return findNextPreprocessedEntity(SLocMapI);
5469 
5470  ModuleFile &M = *SLocMapI->second;
5471  typedef const PPEntityOffset *pp_iterator;
5472  pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5473  pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5474 
5475  size_t Count = M.NumPreprocessedEntities;
5476  size_t Half;
5477  pp_iterator First = pp_begin;
5478  pp_iterator PPI;
5479 
5480  if (EndsAfter) {
5481  PPI = std::upper_bound(pp_begin, pp_end, Loc,
5482  PPEntityComp(*this, M));
5483  } else {
5484  // Do a binary search manually instead of using std::lower_bound because
5485  // The end locations of entities may be unordered (when a macro expansion
5486  // is inside another macro argument), but for this case it is not important
5487  // whether we get the first macro expansion or its containing macro.
5488  while (Count > 0) {
5489  Half = Count / 2;
5490  PPI = First;
5491  std::advance(PPI, Half);
5492  if (SourceMgr.isBeforeInTranslationUnit(
5493  TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5494  First = PPI;
5495  ++First;
5496  Count = Count - Half - 1;
5497  } else
5498  Count = Half;
5499  }
5500  }
5501 
5502  if (PPI == pp_end)
5503  return findNextPreprocessedEntity(SLocMapI);
5504 
5505  return M.BasePreprocessedEntityID + (PPI - pp_begin);
5506 }
5507 
5508 /// \brief Returns a pair of [Begin, End) indices of preallocated
5509 /// preprocessed entities that \arg Range encompasses.
5510 std::pair<unsigned, unsigned>
5512  if (Range.isInvalid())
5513  return std::make_pair(0,0);
5514  assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5515 
5516  PreprocessedEntityID BeginID =
5517  findPreprocessedEntity(Range.getBegin(), false);
5518  PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5519  return std::make_pair(BeginID, EndID);
5520 }
5521 
5522 /// \brief Optionally returns true or false if the preallocated preprocessed
5523 /// entity with index \arg Index came from file \arg FID.
5525  FileID FID) {
5526  if (FID.isInvalid())
5527  return false;
5528 
5529  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5530  ModuleFile &M = *PPInfo.first;
5531  unsigned LocalIndex = PPInfo.second;
5532  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5533 
5534  SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5535  if (Loc.isInvalid())
5536  return false;
5537 
5538  if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5539  return true;
5540  else
5541  return false;
5542 }
5543 
5544 namespace {
5545 
5546  /// \brief Visitor used to search for information about a header file.
5547  class HeaderFileInfoVisitor {
5548  const FileEntry *FE;
5549 
5551 
5552  public:
5553  explicit HeaderFileInfoVisitor(const FileEntry *FE)
5554  : FE(FE) { }
5555 
5556  bool operator()(ModuleFile &M) {
5558  = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5559  if (!Table)
5560  return false;
5561 
5562  // Look in the on-disk hash table for an entry for this file name.
5563  HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5564  if (Pos == Table->end())
5565  return false;
5566 
5567  HFI = *Pos;
5568  return true;
5569  }
5570 
5571  Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5572  };
5573 
5574 } // end anonymous namespace
5575 
5577  HeaderFileInfoVisitor Visitor(FE);
5578  ModuleMgr.visit(Visitor);
5579  if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5580  return *HFI;
5581 
5582  return HeaderFileInfo();
5583 }
5584 
5586  using DiagState = DiagnosticsEngine::DiagState;
5587  SmallVector<DiagState *, 32> DiagStates;
5588 
5589  for (ModuleFile &F : ModuleMgr) {
5590  unsigned Idx = 0;
5591  auto &Record = F.PragmaDiagMappings;
5592  if (Record.empty())
5593  continue;
5594 
5595  DiagStates.clear();
5596 
5597  auto ReadDiagState =
5598  [&](const DiagState &BasedOn, SourceLocation Loc,
5599  bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5600  unsigned BackrefID = Record[Idx++];
5601  if (BackrefID != 0)
5602  return DiagStates[BackrefID - 1];
5603 
5604  // A new DiagState was created here.
5605  Diag.DiagStates.push_back(BasedOn);
5606  DiagState *NewState = &Diag.DiagStates.back();
5607  DiagStates.push_back(NewState);
5608  unsigned Size = Record[Idx++];
5609  assert(Idx + Size * 2 <= Record.size() &&
5610  "Invalid data, not enough diag/map pairs");
5611  while (Size--) {
5612  unsigned DiagID = Record[Idx++];
5613  DiagnosticMapping NewMapping =
5614  DiagnosticMapping::deserialize(Record[Idx++]);
5615  if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5616  continue;
5617 
5618  DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5619 
5620  // If this mapping was specified as a warning but the severity was
5621  // upgraded due to diagnostic settings, simulate the current diagnostic
5622  // settings (and use a warning).
5623  if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5625  NewMapping.setUpgradedFromWarning(false);
5626  }
5627 
5628  Mapping = NewMapping;
5629  }
5630  return NewState;
5631  };
5632 
5633  // Read the first state.
5634  DiagState *FirstState;
5635  if (F.Kind == MK_ImplicitModule) {
5636  // Implicitly-built modules are reused with different diagnostic
5637  // settings. Use the initial diagnostic state from Diag to simulate this
5638  // compilation's diagnostic settings.
5639  FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5640  DiagStates.push_back(FirstState);
5641 
5642  // Skip the initial diagnostic state from the serialized module.
5643  assert(Record[1] == 0 &&
5644  "Invalid data, unexpected backref in initial state");
5645  Idx = 3 + Record[2] * 2;
5646  assert(Idx < Record.size() &&
5647  "Invalid data, not enough state change pairs in initial state");
5648  } else if (F.isModule()) {
5649  // For an explicit module, preserve the flags from the module build
5650  // command line (-w, -Weverything, -Werror, ...) along with any explicit
5651  // -Wblah flags.
5652  unsigned Flags = Record[Idx++];
5653  DiagState Initial;
5654  Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5655  Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5656  Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5657  Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5658  Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5659  Initial.ExtBehavior = (diag::Severity)Flags;
5660  FirstState = ReadDiagState(Initial, SourceLocation(), true);
5661 
5662  // Set up the root buffer of the module to start with the initial
5663  // diagnostic state of the module itself, to cover files that contain no
5664  // explicit transitions (for which we did not serialize anything).
5665  Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5666  .StateTransitions.push_back({FirstState, 0});
5667  } else {
5668  // For prefix ASTs, start with whatever the user configured on the
5669  // command line.
5670  Idx++; // Skip flags.
5671  FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5672  SourceLocation(), false);
5673  }
5674 
5675  // Read the state transitions.
5676  unsigned NumLocations = Record[Idx++];
5677  while (NumLocations--) {
5678  assert(Idx < Record.size() &&
5679  "Invalid data, missing pragma diagnostic states");
5680  SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5681  auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5682  assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5683  unsigned Transitions = Record[Idx++];
5684 
5685  // Note that we don't need to set up Parent/ParentOffset here, because
5686  // we won't be changing the diagnostic state within imported FileIDs
5687  // (other than perhaps appending to the main source file, which has no
5688  // parent).
5689  auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5690  F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5691  for (unsigned I = 0; I != Transitions; ++I) {
5692  unsigned Offset = Record[Idx++];
5693  auto *State =
5694  ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5695  F.StateTransitions.push_back({State, Offset});
5696  }
5697  }
5698 
5699  // Read the final state.
5700  assert(Idx < Record.size() &&
5701  "Invalid data, missing final pragma diagnostic state");
5702  SourceLocation CurStateLoc =
5703  ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5704  auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5705 
5706  if (!F.isModule()) {
5707  Diag.DiagStatesByLoc.CurDiagState = CurState;
5708  Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5709 
5710  // Preserve the property that the imaginary root file describes the
5711  // current state.
5712  auto &T = Diag.DiagStatesByLoc.Files[FileID()].StateTransitions;
5713  if (T.empty())
5714  T.push_back({CurState, 0});
5715  else
5716  T[0].State = CurState;
5717  }
5718 
5719  // Don't try to read these mappings again.
5720  Record.clear();
5721  }
5722 }
5723 
5724 /// \brief Get the correct cursor and offset for loading a type.
5725 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5726  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5727  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5728  ModuleFile *M = I->second;
5729  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5730 }
5731 
5732 /// \brief Read and return the type with the given index..
5733 ///
5734 /// The index is the type ID, shifted and minus the number of predefs. This
5735 /// routine actually reads the record corresponding to the type at the given
5736 /// location. It is a helper routine for GetType, which deals with reading type
5737 /// IDs.
5738 QualType ASTReader::readTypeRecord(unsigned Index) {
5739  assert(ContextObj && "reading type with no AST context");
5740  ASTContext &Context = *ContextObj;
5741  RecordLocation Loc = TypeCursorForIndex(Index);
5742  BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5743 
5744  // Keep track of where we are in the stream, then jump back there
5745  // after reading this type.
5746  SavedStreamPosition SavedPosition(DeclsCursor);
5747 
5748  ReadingKindTracker ReadingKind(Read_Type, *this);
5749 
5750  // Note that we are loading a type record.
5751  Deserializing AType(this);
5752 
5753  unsigned Idx = 0;
5754  DeclsCursor.JumpToBit(Loc.Offset);
5755  RecordData Record;
5756  unsigned Code = DeclsCursor.ReadCode();
5757  switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5758  case TYPE_EXT_QUAL: {
5759  if (Record.size() != 2) {
5760  Error("Incorrect encoding of extended qualifier type");
5761  return QualType();
5762  }
5763  QualType Base = readType(*Loc.F, Record, Idx);
5764  Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5765  return Context.getQualifiedType(Base, Quals);
5766  }
5767 
5768  case TYPE_COMPLEX: {
5769  if (Record.size() != 1) {
5770  Error("Incorrect encoding of complex type");
5771  return QualType();
5772  }
5773  QualType ElemType = readType(*Loc.F, Record, Idx);
5774  return Context.getComplexType(ElemType);
5775  }
5776 
5777  case TYPE_POINTER: {
5778  if (Record.size() != 1) {
5779  Error("Incorrect encoding of pointer type");
5780  return QualType();
5781  }
5782  QualType PointeeType = readType(*Loc.F, Record, Idx);
5783  return Context.getPointerType(PointeeType);
5784  }
5785 
5786  case TYPE_DECAYED: {
5787  if (Record.size() != 1) {
5788  Error("Incorrect encoding of decayed type");
5789  return QualType();
5790  }
5791  QualType OriginalType = readType(*Loc.F, Record, Idx);
5792  QualType DT = Context.getAdjustedParameterType(OriginalType);
5793  if (!isa<DecayedType>(DT))
5794  Error("Decayed type does not decay");
5795  return DT;
5796  }
5797 
5798  case TYPE_ADJUSTED: {
5799  if (Record.size() != 2) {
5800  Error("Incorrect encoding of adjusted type");
5801  return QualType();
5802  }
5803  QualType OriginalTy = readType(*Loc.F, Record, Idx);
5804  QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5805  return Context.getAdjustedType(OriginalTy, AdjustedTy);
5806  }
5807 
5808  case TYPE_BLOCK_POINTER: {
5809  if (Record.size() != 1) {
5810  Error("Incorrect encoding of block pointer type");
5811  return QualType();
5812  }
5813  QualType PointeeType = readType(*Loc.F, Record, Idx);
5814  return Context.getBlockPointerType(PointeeType);
5815  }
5816 
5817  case TYPE_LVALUE_REFERENCE: {
5818  if (Record.size() != 2) {
5819  Error("Incorrect encoding of lvalue reference type");
5820  return QualType();
5821  }
5822  QualType PointeeType = readType(*Loc.F, Record, Idx);
5823  return Context.getLValueReferenceType(PointeeType, Record[1]);
5824  }
5825 
5826  case TYPE_RVALUE_REFERENCE: {
5827  if (Record.size() != 1) {
5828  Error("Incorrect encoding of rvalue reference type");
5829  return QualType();
5830  }
5831  QualType PointeeType = readType(*Loc.F, Record, Idx);
5832  return Context.getRValueReferenceType(PointeeType);
5833  }
5834 
5835  case TYPE_MEMBER_POINTER: {
5836  if (Record.size() != 2) {
5837  Error("Incorrect encoding of member pointer type");
5838  return QualType();
5839  }
5840  QualType PointeeType = readType(*Loc.F, Record, Idx);
5841  QualType ClassType = readType(*Loc.F, Record, Idx);
5842  if (PointeeType.isNull() || ClassType.isNull())
5843  return QualType();
5844 
5845  return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5846  }
5847 
5848  case TYPE_CONSTANT_ARRAY: {
5849  QualType ElementType = readType(*Loc.F, Record, Idx);
5851  unsigned IndexTypeQuals = Record[2];
5852  unsigned Idx = 3;
5853  llvm::APInt Size = ReadAPInt(Record, Idx);
5854  return Context.getConstantArrayType(ElementType, Size,
5855  ASM, IndexTypeQuals);
5856  }
5857 
5858  case TYPE_INCOMPLETE_ARRAY: {
5859  QualType ElementType = readType(*Loc.F, Record, Idx);
5861  unsigned IndexTypeQuals = Record[2];
5862  return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5863  }
5864 
5865  case TYPE_VARIABLE_ARRAY: {
5866  QualType ElementType = readType(*Loc.F, Record, Idx);
5868  unsigned IndexTypeQuals = Record[2];
5869  SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5870  SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5871  return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5872  ASM, IndexTypeQuals,
5873  SourceRange(LBLoc, RBLoc));
5874  }
5875 
5876  case TYPE_VECTOR: {
5877  if (Record.size() != 3) {
5878  Error("incorrect encoding of vector type in AST file");
5879  return QualType();
5880  }
5881 
5882  QualType ElementType = readType(*Loc.F, Record, Idx);
5883  unsigned NumElements = Record[1];
5884  unsigned VecKind = Record[2];
5885  return Context.getVectorType(ElementType, NumElements,
5886  (VectorType::VectorKind)VecKind);
5887  }
5888 
5889  case TYPE_EXT_VECTOR: {
5890  if (Record.size() != 3) {
5891  Error("incorrect encoding of extended vector type in AST file");
5892  return QualType();
5893  }
5894 
5895  QualType ElementType = readType(*Loc.F, Record, Idx);
5896  unsigned NumElements = Record[1];
5897  return Context.getExtVectorType(ElementType, NumElements);
5898  }
5899 
5900  case TYPE_FUNCTION_NO_PROTO: {
5901  if (Record.size() != 7) {
5902  Error("incorrect encoding of no-proto function type");
5903  return QualType();
5904  }
5905  QualType ResultType = readType(*Loc.F, Record, Idx);
5906  FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5907  (CallingConv)Record[4], Record[5], Record[6]);
5908  return Context.getFunctionNoProtoType(ResultType, Info);
5909  }
5910 
5911  case TYPE_FUNCTION_PROTO: {
5912  QualType ResultType = readType(*Loc.F, Record, Idx);
5913 
5915  EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5916  /*hasregparm*/ Record[2],
5917  /*regparm*/ Record[3],
5918  static_cast<CallingConv>(Record[4]),
5919  /*produces*/ Record[5],
5920  /*nocallersavedregs*/ Record[6]);
5921 
5922  unsigned Idx = 7;
5923 
5924  EPI.Variadic = Record[Idx++];
5925  EPI.HasTrailingReturn = Record[Idx++];
5926  EPI.TypeQuals = Record[Idx++];
5927  EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5928  SmallVector<QualType, 8> ExceptionStorage;
5929  readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
5930 
5931  unsigned NumParams = Record[Idx++];
5932  SmallVector<QualType, 16> ParamTypes;
5933  for (unsigned I = 0; I != NumParams; ++I)
5934  ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5935 
5937  if (Idx != Record.size()) {
5938  for (unsigned I = 0; I != NumParams; ++I)
5939  ExtParameterInfos.push_back(
5941  ::getFromOpaqueValue(Record[Idx++]));
5942  EPI.ExtParameterInfos = ExtParameterInfos.data();
5943  }
5944 
5945  assert(Idx == Record.size());
5946 
5947  return Context.getFunctionType(ResultType, ParamTypes, EPI);
5948  }
5949 
5950  case TYPE_UNRESOLVED_USING: {
5951  unsigned Idx = 0;
5952  return Context.getTypeDeclType(
5953  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5954  }
5955 
5956  case TYPE_TYPEDEF: {
5957  if (Record.size() != 2) {
5958  Error("incorrect encoding of typedef type");
5959  return QualType();
5960  }
5961  unsigned Idx = 0;
5962  TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5963  QualType Canonical = readType(*Loc.F, Record, Idx);
5964  if (!Canonical.isNull())
5965  Canonical = Context.getCanonicalType(Canonical);
5966  return Context.getTypedefType(Decl, Canonical);
5967  }
5968 
5969  case TYPE_TYPEOF_EXPR:
5970  return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5971 
5972  case TYPE_TYPEOF: {
5973  if (Record.size() != 1) {
5974  Error("incorrect encoding of typeof(type) in AST file");
5975  return QualType();
5976  }
5977  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5978  return Context.getTypeOfType(UnderlyingType);
5979  }
5980 
5981  case TYPE_DECLTYPE: {
5982  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5983  return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5984  }
5985 
5986  case TYPE_UNARY_TRANSFORM: {
5987  QualType BaseType = readType(*Loc.F, Record, Idx);
5988  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5990  return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5991  }
5992 
5993  case TYPE_AUTO: {
5994  QualType Deduced = readType(*Loc.F, Record, Idx);
5995  AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
5996  bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
5997  return Context.getAutoType(Deduced, Keyword, IsDependent);
5998  }
5999 
6001  TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6002  QualType Deduced = readType(*Loc.F, Record, Idx);
6003  bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6004  return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6005  IsDependent);
6006  }
6007 
6008  case TYPE_RECORD: {
6009  if (Record.size() != 2) {
6010  Error("incorrect encoding of record type");
6011  return QualType();
6012  }
6013  unsigned Idx = 0;
6014  bool IsDependent = Record[Idx++];
6015  RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6016  RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6017  QualType T = Context.getRecordType(RD);
6018  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6019  return T;
6020  }
6021 
6022  case TYPE_ENUM: {
6023  if (Record.size() != 2) {
6024  Error("incorrect encoding of enum type");
6025  return QualType();
6026  }
6027  unsigned Idx = 0;
6028  bool IsDependent = Record[Idx++];
6029  QualType T
6030  = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6031  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6032  return T;
6033  }
6034 
6035  case TYPE_ATTRIBUTED: {
6036  if (Record.size() != 3) {
6037  Error("incorrect encoding of attributed type");
6038  return QualType();
6039  }
6040  QualType modifiedType = readType(*Loc.F, Record, Idx);
6041  QualType equivalentType = readType(*Loc.F, Record, Idx);
6042  AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6043  return Context.getAttributedType(kind, modifiedType, equivalentType);
6044  }
6045 
6046  case TYPE_PAREN: {
6047  if (Record.size() != 1) {
6048  Error("incorrect encoding of paren type");
6049  return QualType();
6050  }
6051  QualType InnerType = readType(*Loc.F, Record, Idx);
6052  return Context.getParenType(InnerType);
6053  }
6054 
6055  case TYPE_PACK_EXPANSION: {
6056  if (Record.size() != 2) {
6057  Error("incorrect encoding of pack expansion type");
6058  return QualType();
6059  }
6060  QualType Pattern = readType(*Loc.F, Record, Idx);
6061  if (Pattern.isNull())
6062  return QualType();
6063  Optional<unsigned> NumExpansions;
6064  if (Record[1])
6065  NumExpansions = Record[1] - 1;
6066  return Context.getPackExpansionType(Pattern, NumExpansions);
6067  }
6068 
6069  case TYPE_ELABORATED: {
6070  unsigned Idx = 0;
6071  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6072  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6073  QualType NamedType = readType(*Loc.F, Record, Idx);
6074  return Context.getElaboratedType(Keyword, NNS, NamedType);
6075  }
6076 
6077  case TYPE_OBJC_INTERFACE: {
6078  unsigned Idx = 0;
6079  ObjCInterfaceDecl *ItfD
6080  = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6081  return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6082  }
6083 
6084  case TYPE_OBJC_TYPE_PARAM: {
6085  unsigned Idx = 0;
6086  ObjCTypeParamDecl *Decl
6087  = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6088  unsigned NumProtos = Record[Idx++];
6090  for (unsigned I = 0; I != NumProtos; ++I)
6091  Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6092  return Context.getObjCTypeParamType(Decl, Protos);
6093  }
6094  case TYPE_OBJC_OBJECT: {
6095  unsigned Idx = 0;
6096  QualType Base = readType(*Loc.F, Record, Idx);
6097  unsigned NumTypeArgs = Record[Idx++];
6098  SmallVector<QualType, 4> TypeArgs;
6099  for (unsigned I = 0; I != NumTypeArgs; ++I)
6100  TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6101  unsigned NumProtos = Record[Idx++];
6103  for (unsigned I = 0; I != NumProtos; ++I)
6104  Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6105  bool IsKindOf = Record[Idx++];
6106  return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6107  }
6108 
6109  case TYPE_OBJC_OBJECT_POINTER: {
6110  unsigned Idx = 0;
6111  QualType Pointee = readType(*Loc.F, Record, Idx);
6112  return Context.getObjCObjectPointerType(Pointee);
6113  }
6114 
6116  unsigned Idx = 0;
6117  QualType Parm = readType(*Loc.F, Record, Idx);
6118  QualType Replacement = readType(*Loc.F, Record, Idx);
6119  return Context.getSubstTemplateTypeParmType(
6120  cast<TemplateTypeParmType>(Parm),
6121  Context.getCanonicalType(Replacement));
6122  }
6123 
6125  unsigned Idx = 0;
6126  QualType Parm = readType(*Loc.F, Record, Idx);
6127  TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6128  return Context.getSubstTemplateTypeParmPackType(
6129  cast<TemplateTypeParmType>(Parm),
6130  ArgPack);
6131  }
6132 
6133  case TYPE_INJECTED_CLASS_NAME: {
6134  CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6135  QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6136  // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6137  // for AST reading, too much interdependencies.
6138  const Type *T = nullptr;
6139  for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6140  if (const Type *Existing = DI->getTypeForDecl()) {
6141  T = Existing;
6142  break;
6143  }
6144  }
6145  if (!T) {
6146  T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6147  for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6148  DI->setTypeForDecl(T);
6149  }
6150  return QualType(T, 0);
6151  }
6152 
6153  case TYPE_TEMPLATE_TYPE_PARM: {
6154  unsigned Idx = 0;
6155  unsigned Depth = Record[Idx++];
6156  unsigned Index = Record[Idx++];
6157  bool Pack = Record[Idx++];
6159  = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6160  return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6161  }
6162 
6163  case TYPE_DEPENDENT_NAME: {
6164  unsigned Idx = 0;
6165  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6166  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6167  const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6168  QualType Canon = readType(*Loc.F, Record, Idx);
6169  if (!Canon.isNull())
6170  Canon = Context.getCanonicalType(Canon);
6171  return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6172  }
6173 
6175  unsigned Idx = 0;
6176  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6177  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6178  const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6179  unsigned NumArgs = Record[Idx++];
6181  Args.reserve(NumArgs);
6182  while (NumArgs--)
6183  Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6184  return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6185  Args);
6186  }
6187 
6189  unsigned Idx = 0;
6190 
6191  // ArrayType
6192  QualType ElementType = readType(*Loc.F, Record, Idx);
6194  = (ArrayType::ArraySizeModifier)Record[Idx++];
6195  unsigned IndexTypeQuals = Record[Idx++];
6196 
6197  // DependentSizedArrayType
6198  Expr *NumElts = ReadExpr(*Loc.F);
6199  SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6200 
6201  return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6202  IndexTypeQuals, Brackets);
6203  }
6204 
6206  unsigned Idx = 0;
6207  bool IsDependent = Record[Idx++];
6208  TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6210  ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6211  QualType Underlying = readType(*Loc.F, Record, Idx);
6212  QualType T;
6213  if (Underlying.isNull())
6214  T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6215  else
6216  T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6217  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6218  return T;
6219  }
6220 
6221  case TYPE_ATOMIC: {
6222  if (Record.size() != 1) {
6223  Error("Incorrect encoding of atomic type");
6224  return QualType();
6225  }
6226  QualType ValueType = readType(*Loc.F, Record, Idx);
6227  return Context.getAtomicType(ValueType);
6228  }
6229 
6230  case TYPE_PIPE: {
6231  if (Record.size() != 2) {
6232  Error("Incorrect encoding of pipe type");
6233  return QualType();
6234  }
6235 
6236  // Reading the pipe element type.
6237  QualType ElementType = readType(*Loc.F, Record, Idx);
6238  unsigned ReadOnly = Record[1];
6239  return Context.getPipeType(ElementType, ReadOnly);
6240  }
6241 
6243  unsigned Idx = 0;
6244 
6245  // DependentSizedExtVectorType
6246  QualType ElementType = readType(*Loc.F, Record, Idx);
6247  Expr *SizeExpr = ReadExpr(*Loc.F);
6248  SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6249 
6250  return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6251  AttrLoc);
6252  }
6253  }
6254  llvm_unreachable("Invalid TypeCode!");
6255 }
6256 
6257 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6258  SmallVectorImpl<QualType> &Exceptions,
6260  const RecordData &Record, unsigned &Idx) {
6262  static_cast<ExceptionSpecificationType>(Record[Idx++]);
6263  ESI.Type = EST;
6264  if (EST == EST_Dynamic) {
6265  for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6266  Exceptions.push_back(readType(ModuleFile, Record, Idx));
6267  ESI.Exceptions = Exceptions;
6268  } else if (EST == EST_ComputedNoexcept) {
6269  ESI.NoexceptExpr = ReadExpr(ModuleFile);
6270  } else if (EST == EST_Uninstantiated) {
6271  ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6272  ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6273  } else if (EST == EST_Unevaluated) {
6274  ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6275  }
6276 }
6277 
6278 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6279  ModuleFile *F;
6280  ASTReader *Reader;
6281  const ASTReader::RecordData &Record;
6282  unsigned &Idx;
6283 
6284  SourceLocation ReadSourceLocation() {
6285  return Reader->ReadSourceLocation(*F, Record, Idx);
6286  }
6287 
6288  TypeSourceInfo *GetTypeSourceInfo() {
6289  return Reader->GetTypeSourceInfo(*F, Record, Idx);
6290  }
6291 
6292  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6293  return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6294  }
6295 
6296 public:
6297  TypeLocReader(ModuleFile &F, ASTReader &Reader,
6298  const ASTReader::RecordData &Record, unsigned &Idx)
6299  : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6300 
6301  // We want compile-time assurance that we've enumerated all of
6302  // these, so unfortunately we have to declare them first, then
6303  // define them out-of-line.
6304 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6305 #define TYPELOC(CLASS, PARENT) \
6306  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6307 #include "clang/AST/TypeLocNodes.def"
6308 
6309  void VisitFunctionTypeLoc(FunctionTypeLoc);
6310  void VisitArrayTypeLoc(ArrayTypeLoc);
6311 };
6312 
6313 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6314  // nothing to do
6315 }
6316 
6317 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6318  TL.setBuiltinLoc(ReadSourceLocation());
6319  if (TL.needsExtraLocalData()) {
6320  TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6321  TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6322  TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6323  TL.setModeAttr(Record[Idx++]);
6324  }
6325 }
6326 
6327 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6328  TL.setNameLoc(ReadSourceLocation());
6329 }
6330 
6331 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6332  TL.setStarLoc(ReadSourceLocation());
6333 }
6334 
6335 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6336  // nothing to do
6337 }
6338 
6339 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6340  // nothing to do
6341 }
6342 
6343 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6344  TL.setCaretLoc(ReadSourceLocation());
6345 }
6346 
6347 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6348  TL.setAmpLoc(ReadSourceLocation());
6349 }
6350 
6351 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6352  TL.setAmpAmpLoc(ReadSourceLocation());
6353 }
6354 
6355 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6356  TL.setStarLoc(ReadSourceLocation());
6357  TL.setClassTInfo(GetTypeSourceInfo());
6358 }
6359 
6361  TL.setLBracketLoc(ReadSourceLocation());
6362  TL.setRBracketLoc(ReadSourceLocation());
6363  if (Record[Idx++])
6364  TL.setSizeExpr(Reader->ReadExpr(*F));
6365  else
6366  TL.setSizeExpr(nullptr);
6367 }
6368 
6369 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6370  VisitArrayTypeLoc(TL);
6371 }
6372 
6373 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6374  VisitArrayTypeLoc(TL);
6375 }
6376 
6377 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6378  VisitArrayTypeLoc(TL);
6379 }
6380 
6381 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6383  VisitArrayTypeLoc(TL);
6384 }
6385 
6386 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6388  TL.setNameLoc(ReadSourceLocation());
6389 }
6390 
6391 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6392  TL.setNameLoc(ReadSourceLocation());
6393 }
6394 
6395 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6396  TL.setNameLoc(ReadSourceLocation());
6397 }
6398 
6400  TL.setLocalRangeBegin(ReadSourceLocation());
6401  TL.setLParenLoc(ReadSourceLocation());
6402  TL.setRParenLoc(ReadSourceLocation());
6403  TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6404  Reader->ReadSourceLocation(*F, Record, Idx)));
6405  TL.setLocalRangeEnd(ReadSourceLocation());
6406  for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6407  TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6408  }
6409 }
6410 
6411 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6412  VisitFunctionTypeLoc(TL);
6413 }
6414 
6415 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6416  VisitFunctionTypeLoc(TL);
6417 }
6418 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6419  TL.setNameLoc(ReadSourceLocation());
6420 }
6421 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6422  TL.setNameLoc(ReadSourceLocation());
6423 }
6424 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6425  TL.setTypeofLoc(ReadSourceLocation());
6426  TL.setLParenLoc(ReadSourceLocation());
6427  TL.setRParenLoc(ReadSourceLocation());
6428 }
6429 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6430  TL.setTypeofLoc(ReadSourceLocation());
6431  TL.setLParenLoc(ReadSourceLocation());
6432  TL.setRParenLoc(ReadSourceLocation());
6433  TL.setUnderlyingTInfo(GetTypeSourceInfo());
6434 }
6435 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6436  TL.setNameLoc(ReadSourceLocation());
6437 }
6438 
6439 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6440  TL.setKWLoc(ReadSourceLocation());
6441  TL.setLParenLoc(ReadSourceLocation());
6442  TL.setRParenLoc(ReadSourceLocation());
6443  TL.setUnderlyingTInfo(GetTypeSourceInfo());
6444 }
6445 
6446 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6447  TL.setNameLoc(ReadSourceLocation());
6448 }
6449 
6450 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6452  TL.setTemplateNameLoc(ReadSourceLocation());
6453 }
6454 
6455 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6456  TL.setNameLoc(ReadSourceLocation());
6457 }
6458 
6459 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6460  TL.setNameLoc(ReadSourceLocation());
6461 }
6462 
6463 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6464  TL.setAttrNameLoc(ReadSourceLocation());
6465  if (TL.hasAttrOperand()) {
6466  SourceRange range;
6467  range.setBegin(ReadSourceLocation());
6468  range.setEnd(ReadSourceLocation());
6469  TL.setAttrOperandParensRange(range);
6470  }
6471  if (TL.hasAttrExprOperand()) {
6472  if (Record[Idx++])
6473  TL.setAttrExprOperand(Reader->ReadExpr(*F));
6474  else
6475  TL.setAttrExprOperand(nullptr);
6476  } else if (TL.hasAttrEnumOperand())
6477  TL.setAttrEnumOperandLoc(ReadSourceLocation());
6478 }
6479 
6480 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6481  TL.setNameLoc(ReadSourceLocation());
6482 }
6483 
6484 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6486  TL.setNameLoc(ReadSourceLocation());
6487 }
6488 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6490  TL.setNameLoc(ReadSourceLocation());
6491 }
6492 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6494  TL.setTemplateKeywordLoc(ReadSourceLocation());
6495  TL.setTemplateNameLoc(ReadSourceLocation());
6496  TL.setLAngleLoc(ReadSourceLocation());
6497  TL.setRAngleLoc(ReadSourceLocation());
6498  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6499  TL.setArgLocInfo(
6500  i,
6501  Reader->GetTemplateArgumentLocInfo(
6502  *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6503 }
6504 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6505  TL.setLParenLoc(ReadSourceLocation());
6506  TL.setRParenLoc(ReadSourceLocation());
6507 }
6508 
6509 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6510  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6511  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6512 }
6513 
6514 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6515  TL.setNameLoc(ReadSourceLocation());
6516 }
6517 
6518 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6519  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6520  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6521  TL.setNameLoc(ReadSourceLocation());
6522 }
6523 
6524 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6526  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6527  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6528  TL.setTemplateKeywordLoc(ReadSourceLocation());
6529  TL.setTemplateNameLoc(ReadSourceLocation());
6530  TL.setLAngleLoc(ReadSourceLocation());
6531  TL.setRAngleLoc(ReadSourceLocation());
6532  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6533  TL.setArgLocInfo(
6534  I,
6535  Reader->GetTemplateArgumentLocInfo(
6536  *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6537 }
6538 
6539 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6540  TL.setEllipsisLoc(ReadSourceLocation());
6541 }
6542 
6543 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6544  TL.setNameLoc(ReadSourceLocation());
6545 }
6546 
6547 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6548  if (TL.getNumProtocols()) {
6549  TL.setProtocolLAngleLoc(ReadSourceLocation());
6550  TL.setProtocolRAngleLoc(ReadSourceLocation());
6551  }
6552  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6553  TL.setProtocolLoc(i, ReadSourceLocation());
6554 }
6555 
6556 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6557  TL.setHasBaseTypeAsWritten(Record[Idx++]);
6558  TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6559  TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6560  for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6561  TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6562  TL.setProtocolLAngleLoc(ReadSourceLocation());
6563  TL.setProtocolRAngleLoc(ReadSourceLocation());
6564  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6565  TL.setProtocolLoc(i, ReadSourceLocation());
6566 }
6567 
6568 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6569  TL.setStarLoc(ReadSourceLocation());
6570 }
6571 
6572 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6573  TL.setKWLoc(ReadSourceLocation());
6574  TL.setLParenLoc(ReadSourceLocation());
6575  TL.setRParenLoc(ReadSourceLocation());
6576 }
6577 
6578 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6579  TL.setKWLoc(ReadSourceLocation());
6580 }
6581 
6584  unsigned &Idx) {
6585  QualType InfoTy = readType(F, Record, Idx);
6586  if (InfoTy.isNull())
6587  return nullptr;
6588 
6589  TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6590  TypeLocReader TLR(F, *this, Record, Idx);
6591  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
6592  TLR.Visit(TL);
6593  return TInfo;
6594 }
6595 
6597  assert(ContextObj && "reading type with no AST context");
6598  ASTContext &Context = *ContextObj;
6599 
6600  unsigned FastQuals = ID & Qualifiers::FastMask;
6601  unsigned Index = ID >> Qualifiers::FastWidth;
6602 
6603  if (Index < NUM_PREDEF_TYPE_IDS) {
6604  QualType T;
6605  switch ((PredefinedTypeIDs)Index) {
6606  case PREDEF_TYPE_NULL_ID:
6607  return QualType();
6608  case PREDEF_TYPE_VOID_ID:
6609  T = Context.VoidTy;
6610  break;
6611  case PREDEF_TYPE_BOOL_ID:
6612  T = Context.BoolTy;
6613  break;
6614 
6615  case PREDEF_TYPE_CHAR_U_ID:
6616  case PREDEF_TYPE_CHAR_S_ID:
6617  // FIXME: Check that the signedness of CharTy is correct!
6618  T = Context.CharTy;
6619  break;
6620 
6621  case PREDEF_TYPE_UCHAR_ID:
6622  T = Context.UnsignedCharTy;
6623  break;
6624  case PREDEF_TYPE_USHORT_ID:
6625  T = Context.UnsignedShortTy;
6626  break;
6627  case PREDEF_TYPE_UINT_ID:
6628  T = Context.UnsignedIntTy;
6629  break;
6630  case PREDEF_TYPE_ULONG_ID:
6631  T = Context.UnsignedLongTy;
6632  break;
6634  T = Context.UnsignedLongLongTy;
6635  break;
6637  T = Context.UnsignedInt128Ty;
6638  break;
6639  case PREDEF_TYPE_SCHAR_ID:
6640  T = Context.SignedCharTy;
6641  break;
6642  case PREDEF_TYPE_WCHAR_ID:
6643  T = Context.WCharTy;
6644  break;
6645  case PREDEF_TYPE_SHORT_ID:
6646  T = Context.ShortTy;
6647  break;
6648  case PREDEF_TYPE_INT_ID:
6649  T = Context.IntTy;
6650  break;
6651  case PREDEF_TYPE_LONG_ID:
6652  T = Context.LongTy;
6653  break;
6655  T = Context.LongLongTy;
6656  break;
6657  case PREDEF_TYPE_INT128_ID:
6658  T = Context.Int128Ty;
6659  break;
6660  case PREDEF_TYPE_HALF_ID:
6661  T = Context.HalfTy;
6662  break;
6663  case PREDEF_TYPE_FLOAT_ID:
6664  T = Context.FloatTy;
6665  break;
6666  case PREDEF_TYPE_DOUBLE_ID:
6667  T = Context.DoubleTy;
6668  break;
6670  T = Context.LongDoubleTy;
6671  break;
6673  T = Context.Float128Ty;
6674  break;
6676  T = Context.OverloadTy;
6677  break;
6679  T = Context.BoundMemberTy;
6680  break;
6682  T = Context.PseudoObjectTy;
6683  break;
6685  T = Context.DependentTy;
6686  break;
6688  T = Context.UnknownAnyTy;
6689  break;
6691  T = Context.NullPtrTy;
6692  break;
6693  case PREDEF_TYPE_CHAR16_ID:
6694  T = Context.Char16Ty;
6695  break;
6696  case PREDEF_TYPE_CHAR32_ID:
6697  T = Context.Char32Ty;
6698  break;
6699  case PREDEF_TYPE_OBJC_ID:
6700  T = Context.ObjCBuiltinIdTy;
6701  break;
6703  T = Context.ObjCBuiltinClassTy;
6704  break;
6705  case PREDEF_TYPE_OBJC_SEL:
6706  T = Context.ObjCBuiltinSelTy;
6707  break;
6708 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6709  case PREDEF_TYPE_##Id##_ID: \
6710  T = Context.SingletonId; \
6711  break;
6712 #include "clang/Basic/OpenCLImageTypes.def"
6714  T = Context.OCLSamplerTy;
6715  break;
6716  case PREDEF_TYPE_EVENT_ID:
6717  T = Context.OCLEventTy;
6718  break;
6720  T = Context.OCLClkEventTy;
6721  break;
6722  case PREDEF_TYPE_QUEUE_ID:
6723  T = Context.OCLQueueTy;
6724  break;
6726  T = Context.OCLReserveIDTy;
6727  break;
6729  T = Context.getAutoDeductType();
6730  break;
6731 
6733  T = Context.getAutoRRefDeductType();
6734  break;
6735 
6737  T = Context.ARCUnbridgedCastTy;
6738  break;
6739 
6741  T = Context.BuiltinFnTy;
6742  break;
6743 
6745  T = Context.OMPArraySectionTy;
6746  break;
6747  }
6748 
6749  assert(!T.isNull() && "Unknown predefined type");
6750  return T.withFastQualifiers(FastQuals);
6751  }
6752 
6753  Index -= NUM_PREDEF_TYPE_IDS;
6754  assert(Index < TypesLoaded.size() && "Type index out-of-range");
6755  if (TypesLoaded[Index].isNull()) {
6756  TypesLoaded[Index] = readTypeRecord(Index);
6757  if (TypesLoaded[Index].isNull())
6758  return QualType();
6759 
6760  TypesLoaded[Index]->setFromAST();
6761  if (DeserializationListener)
6762  DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
6763  TypesLoaded[Index]);
6764  }
6765 
6766  return TypesLoaded[Index].withFastQualifiers(FastQuals);
6767 }
6768 
6769 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
6770  return GetType(getGlobalTypeID(F, LocalID));
6771 }
6772 
6774 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
6775  unsigned FastQuals = LocalID & Qualifiers::FastMask;
6776  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
6777 
6778  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
6779  return LocalID;
6780 
6781  if (!F.ModuleOffsetMap.empty())
6782  ReadModuleOffsetMap(F);
6783 
6785  = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
6786  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
6787 
6788  unsigned GlobalIndex = LocalIndex + I->second;
6789  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
6790 }
6791 
6795  const RecordData &Record,
6796  unsigned &Index) {
6797  switch (Kind) {
6799  return ReadExpr(F);
6801  return GetTypeSourceInfo(F, Record, Index);
6803  NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6804  Index);
6805  SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6806  return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6807  SourceLocation());
6808  }
6810  NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6811  Index);
6812  SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6813  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6814  return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6815  EllipsisLoc);
6816  }
6822  // FIXME: Is this right?
6823  return TemplateArgumentLocInfo();
6824  }
6825  llvm_unreachable("unexpected template argument loc");
6826 }
6827 
6830  const RecordData &Record, unsigned &Index) {
6831  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6832 
6833  if (Arg.getKind() == TemplateArgument::Expression) {
6834  if (Record[Index++]) // bool InfoHasSameExpr.
6836  }
6837  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6838  Record, Index));
6839 }
6840 
6843  const RecordData &Record,
6844  unsigned &Index) {
6845  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6846  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6847  unsigned NumArgsAsWritten = Record[Index++];
6848  TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6849  for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6850  TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6851  return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6852 }
6853 
6854 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6855  return GetDecl(ID);
6856 }
6857 
6858 void ASTReader::CompleteRedeclChain(const Decl *D) {
6859  if (NumCurrentElementsDeserializing) {
6860  // We arrange to not care about the complete redeclaration chain while we're
6861  // deserializing. Just remember that the AST has marked this one as complete
6862  // but that it's not actually complete yet, so we know we still need to
6863  // complete it later.
6864  PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6865  return;
6866  }
6867 
6868  const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6869 
6870  // If this is a named declaration, complete it by looking it up
6871  // within its context.
6872  //
6873  // FIXME: Merging a function definition should merge
6874  // all mergeable entities within it.
6875  if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6876  isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6877  if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6878  if (!getContext().getLangOpts().CPlusPlus &&
6879  isa<TranslationUnitDecl>(DC)) {
6880  // Outside of C++, we don't have a lookup table for the TU, so update
6881  // the identifier instead. (For C++ modules, we don't store decls
6882  // in the serialized identifier table, so we do the lookup in the TU.)
6883  auto *II = Name.getAsIdentifierInfo();
6884  assert(II && "non-identifier name in C?");
6885  if (II->isOutOfDate())
6886  updateOutOfDateIdentifier(*II);
6887  } else
6888  DC->lookup(Name);
6889  } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
6890  // Find all declarations of this kind from the relevant context.
6891  for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
6892  auto *DC = cast<DeclContext>(DCDecl);
6893  SmallVector<Decl*, 8> Decls;
6894  FindExternalLexicalDecls(
6895  DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
6896  }
6897  }
6898  }
6899 
6900  if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
6901  CTSD->getSpecializedTemplate()->LoadLazySpecializations();
6902  if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
6903  VTSD->getSpecializedTemplate()->LoadLazySpecializations();
6904  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6905  if (auto *Template = FD->getPrimaryTemplate())
6906  Template->LoadLazySpecializations();
6907  }
6908 }
6909 
6912  RecordLocation Loc = getLocalBitOffset(Offset);
6913  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6914  SavedStreamPosition SavedPosition(Cursor);
6915  Cursor.JumpToBit(Loc.Offset);
6916  ReadingKindTracker ReadingKind(Read_Decl, *this);
6917 
6918  RecordData Record;
6919  unsigned Code = Cursor.ReadCode();
6920  unsigned RecCode = Cursor.readRecord(Code, Record);
6921  if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
6922  Error("malformed AST file: missing C++ ctor initializers");
6923  return nullptr;
6924  }
6925 
6926  unsigned Idx = 0;
6927  return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
6928 }
6929 
6931  assert(ContextObj && "reading base specifiers with no AST context");
6932  ASTContext &Context = *ContextObj;
6933 
6934  RecordLocation Loc = getLocalBitOffset(Offset);
6935  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6936  SavedStreamPosition SavedPosition(Cursor);
6937  Cursor.JumpToBit(Loc.Offset);
6938  ReadingKindTracker ReadingKind(Read_Decl, *this);
6939  RecordData Record;
6940  unsigned Code = Cursor.ReadCode();
6941  unsigned RecCode = Cursor.readRecord(Code, Record);
6942  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
6943  Error("malformed AST file: missing C++ base specifiers");
6944  return nullptr;
6945  }
6946 
6947  unsigned Idx = 0;
6948  unsigned NumBases = Record[Idx++];
6949  void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
6950  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
6951  for (unsigned I = 0; I != NumBases; ++I)
6952  Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
6953  return Bases;
6954 }
6955 
6957 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
6958  if (LocalID < NUM_PREDEF_DECL_IDS)
6959  return LocalID;
6960 
6961  if (!F.ModuleOffsetMap.empty())
6962  ReadModuleOffsetMap(F);
6963 
6965  = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
6966  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
6967 
6968  return LocalID + I->second;
6969 }
6970 
6972  ModuleFile &M) const {
6973  // Predefined decls aren't from any module.
6974  if (ID < NUM_PREDEF_DECL_IDS)
6975  return false;
6976 
6977  return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
6978  ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
6979 }
6980 
6981 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
6982  if (!D->isFromASTFile())
6983  return nullptr;
6984  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
6985  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6986  return I->second;
6987 }
6988 
6990  if (ID < NUM_PREDEF_DECL_IDS)
6991  return SourceLocation();
6992 
6993  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6994 
6995  if (Index > DeclsLoaded.size()) {
6996  Error("declaration ID out-of-range for AST file");
6997  return SourceLocation();
6998  }
6999 
7000  if (Decl *D = DeclsLoaded[Index])
7001  return D->getLocation();
7002 
7003  SourceLocation Loc;
7004  DeclCursorForID(ID, Loc);
7005  return Loc;
7006 }
7007 
7008 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7009  switch (ID) {
7010  case PREDEF_DECL_NULL_ID:
7011  return nullptr;
7012 
7014  return Context.getTranslationUnitDecl();
7015 
7017  return Context.getObjCIdDecl();
7018 
7020  return Context.getObjCSelDecl();
7021 
7023  return Context.getObjCClassDecl();
7024 
7026  return Context.getObjCProtocolDecl();
7027 
7029  return Context.getInt128Decl();
7030 
7032  return Context.getUInt128Decl();
7033 
7035  return Context.getObjCInstanceTypeDecl();
7036 
7038  return Context.getBuiltinVaListDecl();
7039 
7041  return Context.getVaListTagDecl();
7042 
7044  return Context.getBuiltinMSVaListDecl();
7045 
7047  return Context.getExternCContextDecl();
7048 
7050  return Context.getMakeIntegerSeqDecl();
7051 
7053  return Context.getCFConstantStringDecl();
7054 
7056  return Context.getCFConstantStringTagDecl();
7057 
7059  return Context.getTypePackElementDecl();
7060  }
7061  llvm_unreachable("PredefinedDeclIDs unknown enum value");
7062 }
7063 
7065  assert(ContextObj && "reading decl with no AST context");
7066  if (ID < NUM_PREDEF_DECL_IDS) {
7067  Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7068  if (D) {
7069  // Track that we have merged the declaration with ID \p ID into the
7070  // pre-existing predefined declaration \p D.
7071  auto &Merged = KeyDecls[D->getCanonicalDecl()];
7072  if (Merged.empty())
7073  Merged.push_back(ID);
7074  }
7075  return D;
7076  }
7077 
7078  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7079 
7080  if (Index >= DeclsLoaded.size()) {
7081  assert(0 && "declaration ID out-of-range for AST file");
7082  Error("declaration ID out-of-range for AST file");
7083  return nullptr;
7084  }
7085 
7086  return DeclsLoaded[Index];
7087 }
7088 
7090  if (ID < NUM_PREDEF_DECL_IDS)
7091  return GetExistingDecl(ID);
7092 
7093  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7094 
7095  if (Index >= DeclsLoaded.size()) {
7096  assert(0 && "declaration ID out-of-range for AST file");
7097  Error("declaration ID out-of-range for AST file");
7098  return nullptr;
7099  }
7100 
7101  if (!DeclsLoaded[Index]) {
7102  ReadDeclRecord(ID);
7103  if (DeserializationListener)
7104  DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7105  }
7106 
7107  return DeclsLoaded[Index];
7108 }
7109 
7111  DeclID GlobalID) {
7112  if (GlobalID < NUM_PREDEF_DECL_IDS)
7113  return GlobalID;
7114 
7115  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7116  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7117  ModuleFile *Owner = I->second;
7118 
7119  llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7120  = M.GlobalToLocalDeclIDs.find(Owner);
7121  if (Pos == M.GlobalToLocalDeclIDs.end())
7122  return 0;
7123 
7124  return GlobalID - Owner->BaseDeclID + Pos->second;
7125 }
7126 
7128  const RecordData &Record,
7129  unsigned &Idx) {
7130  if (Idx >= Record.size()) {
7131  Error("Corrupted AST file");
7132  return 0;
7133  }
7134 
7135  return getGlobalDeclID(F, Record[Idx++]);
7136 }
7137 
7138 /// \brief Resolve the offset of a statement into a statement.
7139 ///
7140 /// This operation will read a new statement from the external
7141 /// source each time it is called, and is meant to be used via a
7142 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7144  // Switch case IDs are per Decl.
7145  ClearSwitchCaseIDs();
7146 
7147  // Offset here is a global offset across the entire chain.
7148  RecordLocation Loc = getLocalBitOffset(Offset);
7149  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7150  assert(NumCurrentElementsDeserializing == 0 &&
7151  "should not be called while already deserializing");
7152  Deserializing D(this);
7153  return ReadStmtFromStream(*Loc.F);
7154 }
7155 
7157  const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7158  SmallVectorImpl<Decl *> &Decls) {
7159  bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7160 
7161  auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7162  assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7163  for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7164  auto K = (Decl::Kind)+LexicalDecls[I];
7165  if (!IsKindWeWant(K))
7166  continue;
7167 
7168  auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7169 
7170  // Don't add predefined declarations to the lexical context more
7171  // than once.
7172  if (ID < NUM_PREDEF_DECL_IDS) {
7173  if (PredefsVisited[ID])
7174  continue;
7175 
7176  PredefsVisited[ID] = true;
7177  }
7178 
7179  if (Decl *D = GetLocalDecl(*M, ID)) {
7180  assert(D->getKind() == K && "wrong kind for lexical decl");
7181  if (!DC->isDeclInLexicalTraversal(D))
7182  Decls.push_back(D);
7183  }
7184  }
7185  };
7186 
7187  if (isa<TranslationUnitDecl>(DC)) {
7188  for (auto Lexical : TULexicalDecls)
7189  Visit(Lexical.first, Lexical.second);
7190  } else {
7191  auto I = LexicalDecls.find(DC);
7192  if (I != LexicalDecls.end())
7193  Visit(I->second.first, I->second.second);
7194  }
7195 
7196  ++NumLexicalDeclContextsRead;
7197 }
7198 
7199 namespace {
7200 
7201 class DeclIDComp {
7202  ASTReader &Reader;
7203  ModuleFile &Mod;
7204 
7205 public:
7206  DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7207 
7208  bool operator()(LocalDeclID L, LocalDeclID R) const {
7209  SourceLocation LHS = getLocation(L);
7210  SourceLocation RHS = getLocation(R);
7211  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7212  }
7213 
7214  bool operator()(SourceLocation LHS, LocalDeclID R) const {
7215  SourceLocation RHS = getLocation(R);
7216  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7217  }
7218 
7219  bool operator()(LocalDeclID L, SourceLocation RHS) const {
7220  SourceLocation LHS = getLocation(L);
7221  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7222  }
7223 
7224  SourceLocation getLocation(LocalDeclID ID) const {
7225  return Reader.getSourceManager().getFileLoc(
7226  Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7227  }
7228 };
7229 
7230 } // end anonymous namespace
7231 
7233  unsigned Offset, unsigned Length,
7234  SmallVectorImpl<Decl *> &Decls) {
7235  SourceManager &SM = getSourceManager();
7236 
7237  llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7238  if (I == FileDeclIDs.end())
7239  return;
7240 
7241  FileDeclsInfo &DInfo = I->second;
7242  if (DInfo.Decls.empty())
7243  return;
7244 
7246  BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7247  SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7248 
7249  DeclIDComp DIDComp(*this, *DInfo.Mod);
7251  BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7252  BeginLoc, DIDComp);
7253  if (BeginIt != DInfo.Decls.begin())
7254  --BeginIt;
7255 
7256  // If we are pointing at a top-level decl inside an objc container, we need
7257  // to backtrack until we find it otherwise we will fail to report that the
7258  // region overlaps with an objc container.
7259  while (BeginIt != DInfo.Decls.begin() &&
7260  GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7261  ->isTopLevelDeclInObjCContainer())
7262  --BeginIt;
7263 
7265  EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7266  EndLoc, DIDComp);
7267  if (EndIt != DInfo.Decls.end())
7268  ++EndIt;
7269 
7271  DIt = BeginIt; DIt != EndIt; ++DIt)
7272  Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7273 }
7274 
7275 bool
7277  DeclarationName Name) {
7278  assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7279  "DeclContext has no visible decls in storage");
7280  if (!Name)
7281  return false;
7282 
7283  auto It = Lookups.find(DC);
7284  if (It == Lookups.end())
7285  return false;
7286 
7287  Deserializing LookupResults(this);
7288 
7289  // Load the list of declarations.
7291  for (DeclID ID : It->second.Table.find(Name)) {
7292  NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7293  if (ND->getDeclName() == Name)
7294  Decls.push_back(ND);
7295  }
7296 
7297  ++NumVisibleDeclContextsRead;
7298  SetExternalVisibleDeclsForName(DC, Name, Decls);
7299  return !Decls.empty();
7300 }
7301 
7303  if (!DC->hasExternalVisibleStorage())
7304  return;
7305 
7306  auto It = Lookups.find(DC);
7307  assert(It != Lookups.end() &&
7308  "have external visible storage but no lookup tables");
7309 
7310  DeclsMap Decls;
7311 
7312  for (DeclID ID : It->second.Table.findAll()) {
7313  NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7314  Decls[ND->getDeclName()].push_back(ND);
7315  }
7316 
7317  ++NumVisibleDeclContextsRead;
7318 
7319  for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7320  SetExternalVisibleDeclsForName(DC, I->first, I->second);
7321  }
7322  const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7323 }
7324 
7327  auto I = Lookups.find(Primary);
7328  return I == Lookups.end() ? nullptr : &I->second;
7329 }
7330 
7331 /// \brief Under non-PCH compilation the consumer receives the objc methods
7332 /// before receiving the implementation, and codegen depends on this.
7333 /// We simulate this by deserializing and passing to consumer the methods of the
7334 /// implementation before passing the deserialized implementation decl.
7336  ASTConsumer *Consumer) {
7337  assert(ImplD && Consumer);
7338 
7339  for (auto *I : ImplD->methods())
7340  Consumer->HandleInterestingDecl(DeclGroupRef(I));
7341 
7342  Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7343 }
7344 
7345 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7346  if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7347  PassObjCImplDeclToConsumer(ImplD, Consumer);
7348  else
7349  Consumer->HandleInterestingDecl(DeclGroupRef(D));
7350 }
7351 
7353  this->Consumer = Consumer;
7354 
7355  if (Consumer)
7356  PassInterestingDeclsToConsumer();
7357 
7358  if (DeserializationListener)
7359  DeserializationListener->ReaderInitialized(this);
7360 }
7361 
7363  std::fprintf(stderr, "*** AST File Statistics:\n");
7364 
7365  unsigned NumTypesLoaded
7366  = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7367  QualType());
7368  unsigned NumDeclsLoaded
7369  = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7370  (Decl *)nullptr);
7371  unsigned NumIdentifiersLoaded
7372  = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7373  IdentifiersLoaded.end(),
7374  (IdentifierInfo *)nullptr);
7375  unsigned NumMacrosLoaded
7376  = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7377  MacrosLoaded.end(),
7378  (MacroInfo *)nullptr);
7379  unsigned NumSelectorsLoaded
7380  = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7381  SelectorsLoaded.end(),
7382  Selector());
7383 
7384  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7385  std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7386  NumSLocEntriesRead, TotalNumSLocEntries,
7387  ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7388  if (!TypesLoaded.empty())
7389  std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7390  NumTypesLoaded, (unsigned)TypesLoaded.size(),
7391  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7392  if (!DeclsLoaded.empty())
7393  std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7394  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7395  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7396  if (!IdentifiersLoaded.empty())
7397  std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7398  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7399  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7400  if (!MacrosLoaded.empty())
7401  std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7402  NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7403  ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7404  if (!SelectorsLoaded.empty())
7405  std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7406  NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7407  ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7408  if (TotalNumStatements)
7409  std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7410  NumStatementsRead, TotalNumStatements,
7411  ((float)NumStatementsRead/TotalNumStatements * 100));
7412  if (TotalNumMacros)
7413  std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7414  NumMacrosRead, TotalNumMacros,
7415  ((float)NumMacrosRead/TotalNumMacros * 100));
7416  if (TotalLexicalDeclContexts)
7417  std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7418  NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7419  ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7420  * 100));
7421  if (TotalVisibleDeclContexts)
7422  std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7423  NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7424  ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7425  * 100));
7426  if (TotalNumMethodPoolEntries) {
7427  std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7428  NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7429  ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7430  * 100));
7431  }
7432  if (NumMethodPoolLookups) {
7433  std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7434  NumMethodPoolHits, NumMethodPoolLookups,
7435  ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7436  }
7437  if (NumMethodPoolTableLookups) {
7438  std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7439  NumMethodPoolTableHits, NumMethodPoolTableLookups,
7440  ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7441  * 100.0));
7442  }
7443 
7444  if (NumIdentifierLookupHits) {
7445  std::fprintf(stderr,
7446  " %u / %u identifier table lookups succeeded (%f%%)\n",
7447  NumIdentifierLookupHits, NumIdentifierLookups,
7448  (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7449  }
7450 
7451  if (GlobalIndex) {
7452  std::fprintf(stderr, "\n");
7453  GlobalIndex->printStats();
7454  }
7455 
7456  std::fprintf(stderr, "\n");
7457  dump();
7458  std::fprintf(stderr, "\n");
7459 }
7460 
7461 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7462 LLVM_DUMP_METHOD static void
7463 dumpModuleIDMap(StringRef Name,
7464  const ContinuousRangeMap<Key, ModuleFile *,
7465  InitialCapacity> &Map) {
7466  if (Map.begin() == Map.end())
7467  return;
7468 
7470  llvm::errs() << Name << ":\n";
7471  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7472  I != IEnd; ++I) {
7473  llvm::errs() << " " << I->first << " -> " << I->second->FileName
7474  << "\n";
7475  }
7476 }
7477 
7478 LLVM_DUMP_METHOD void ASTReader::dump() {
7479  llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7480  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7481  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7482  dumpModuleIDMap("Global type map", GlobalTypeMap);
7483  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7484  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7485  dumpModuleIDMap("Global macro map", GlobalMacroMap);
7486  dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7487  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7488  dumpModuleIDMap("Global preprocessed entity map",
7489  GlobalPreprocessedEntityMap);
7490 
7491  llvm::errs() << "\n*** PCH/Modules Loaded:";
7492  for (ModuleFile &M : ModuleMgr)
7493  M.dump();
7494 }
7495 
7496 /// Return the amount of memory used by memory buffers, breaking down
7497 /// by heap-backed versus mmap'ed memory.
7499  for (ModuleFile &I : ModuleMgr) {
7500  if (llvm::MemoryBuffer *buf = I.Buffer) {
7501  size_t bytes = buf->getBufferSize();
7502  switch (buf->getBufferKind()) {
7503  case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7504  sizes.malloc_bytes += bytes;
7505  break;
7506  case llvm::MemoryBuffer::MemoryBuffer_MMap:
7507  sizes.mmap_bytes += bytes;
7508  break;
7509  }
7510  }
7511  }
7512 }
7513 
7515  SemaObj = &S;
7516  S.addExternalSource(this);
7517 
7518  // Makes sure any declarations that were deserialized "too early"
7519  // still get added to the identifier's declaration chains.
7520  for (uint64_t ID : PreloadedDeclIDs) {
7521  NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7522  pushExternalDeclIntoScope(D, D->getDeclName());
7523  }
7524  PreloadedDeclIDs.clear();
7525 
7526  // FIXME: What happens if these are changed by a module import?
7527  if (!FPPragmaOptions.empty()) {
7528  assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7529  SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7530  }
7531 
7532  SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7533  SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7534  SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7535 
7536  UpdateSema();
7537 }
7538 
7540  assert(SemaObj && "no Sema to update");
7541 
7542  // Load the offsets of the declarations that Sema references.
7543  // They will be lazily deserialized when needed.
7544  if (!SemaDeclRefs.empty()) {
7545  assert(SemaDeclRefs.size() % 3 == 0);
7546  for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7547  if (!SemaObj->StdNamespace)
7548  SemaObj->StdNamespace = SemaDeclRefs[I];
7549  if (!SemaObj->StdBadAlloc)
7550  SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7551  if (!SemaObj->StdAlignValT)
7552  SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7553  }
7554  SemaDeclRefs.clear();
7555  }
7556 
7557  // Update the state of pragmas. Use the same API as if we had encountered the
7558  // pragma in the source.
7559  if(OptimizeOffPragmaLocation.isValid())
7560  SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7561  if (PragmaMSStructState != -1)
7562  SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7563  if (PointersToMembersPragmaLocation.isValid()) {
7564  SemaObj->ActOnPragmaMSPointersToMembers(
7566  PragmaMSPointersToMembersState,
7567  PointersToMembersPragmaLocation);
7568  }
7569  SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7570 
7571  if (PragmaPackCurrentValue) {
7572  // The bottom of the stack might have a default value. It must be adjusted
7573  // to the current value to ensure that the packing state is preserved after
7574  // popping entries that were included/imported from a PCH/module.
7575  bool DropFirst = false;
7576  if (!PragmaPackStack.empty() &&
7577  PragmaPackStack.front().Location.isInvalid()) {
7578  assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7579  "Expected a default alignment value");
7580  SemaObj->PackStack.Stack.emplace_back(
7581  PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7582  SemaObj->PackStack.CurrentPragmaLocation);
7583  DropFirst = true;
7584  }
7585  for (const auto &Entry :
7586  llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7587  SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7588  Entry.Location);
7589  if (PragmaPackCurrentLocation.isInvalid()) {
7590  assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7591  "Expected a default alignment value");
7592  // Keep the current values.
7593  } else {
7594  SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7595  SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7596  }
7597  }
7598 }
7599 
7600 IdentifierInfo *ASTReader::get(StringRef Name) {
7601  // Note that we are loading an identifier.
7602  Deserializing AnIdentifier(this);
7603 
7604  IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7605  NumIdentifierLookups,
7606  NumIdentifierLookupHits);
7607 
7608  // We don't need to do identifier table lookups in C++ modules (we preload
7609  // all interesting declarations, and don't need to use the scope for name
7610  // lookups). Perform the lookup in PCH files, though, since we don't build
7611  // a complete initial identifier table if we're carrying on from a PCH.
7612  if (PP.getLangOpts().CPlusPlus) {
7613  for (auto F : ModuleMgr.pch_modules())
7614  if (Visitor(*F))
7615  break;
7616  } else {
7617  // If there is a global index, look there first to determine which modules
7618  // provably do not have any results for this identifier.
7620  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7621  if (!loadGlobalIndex()) {
7622  if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7623  HitsPtr = &Hits;
7624  }
7625  }
7626 
7627  ModuleMgr.visit(Visitor, HitsPtr);
7628  }
7629 
7630  IdentifierInfo *II = Visitor.getIdentifierInfo();
7631  markIdentifierUpToDate(II);
7632  return II;
7633 }
7634 
7635 namespace clang {
7636 
7637  /// \brief An identifier-lookup iterator that enumerates all of the
7638  /// identifiers stored within a set of AST files.
7640  /// \brief The AST reader whose identifiers are being enumerated.
7641  const ASTReader &Reader;
7642 
7643  /// \brief The current index into the chain of AST files stored in
7644  /// the AST reader.
7645  unsigned Index;
7646 
7647  /// \brief The current position within the identifier lookup table
7648  /// of the current AST file.
7649  ASTIdentifierLookupTable::key_iterator Current;
7650 
7651  /// \brief The end position within the identifier lookup table of
7652  /// the current AST file.
7653  ASTIdentifierLookupTable::key_iterator End;
7654 
7655  /// \brief Whether to skip any modules in the ASTReader.
7656  bool SkipModules;
7657 
7658  public:
7659  explicit ASTIdentifierIterator(const ASTReader &Reader,
7660  bool SkipModules = false);
7661 
7662  StringRef Next() override;
7663  };
7664 
7665 } // end namespace clang
7666 
7668  bool SkipModules)
7669  : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7670 }
7671 
7673  while (Current == End) {
7674  // If we have exhausted all of our AST files, we're done.
7675  if (Index == 0)
7676  return StringRef();
7677 
7678  --Index;
7679  ModuleFile &F = Reader.ModuleMgr[Index];
7680  if (SkipModules && F.isModule())
7681  continue;
7682 
7683  ASTIdentifierLookupTable *IdTable =
7684  (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
7685  Current = IdTable->key_begin();
7686  End = IdTable->key_end();
7687  }
7688 
7689  // We have any identifiers remaining in the current AST file; return
7690  // the next one.
7691  StringRef Result = *Current;
7692  ++Current;
7693  return Result;
7694 }
7695 
7696 namespace {
7697 
7698 /// A utility for appending two IdentifierIterators.
7699 class ChainedIdentifierIterator : public IdentifierIterator {
7700  std::unique_ptr<IdentifierIterator> Current;
7701  std::unique_ptr<IdentifierIterator> Queued;
7702 
7703 public:
7704  ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7705  std::unique_ptr<IdentifierIterator> Second)
7706  : Current(std::move(First)), Queued(std::move(Second)) {}
7707 
7708  StringRef Next() override {
7709  if (!Current)
7710  return StringRef();
7711 
7712  StringRef result = Current->Next();
7713  if (!result.empty())
7714  return result;
7715 
7716  // Try the queued iterator, which may itself be empty.
7717  Current.reset();
7718  std::swap(Current, Queued);
7719  return Next();
7720  }
7721 };
7722 
7723 } // end anonymous namespace.
7724 
7726  if (!loadGlobalIndex()) {
7727  std::unique_ptr<IdentifierIterator> ReaderIter(
7728  new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7729  std::unique_ptr<IdentifierIterator> ModulesIter(
7730  GlobalIndex->createIdentifierIterator());
7731  return new ChainedIdentifierIterator(std::move(ReaderIter),
7732  std::move(ModulesIter));
7733  }
7734 
7735  return new ASTIdentifierIterator(*this);
7736 }
7737 
7738 namespace clang {
7739 namespace serialization {
7740 
7742  ASTReader &Reader;
7743  Selector Sel;
7744  unsigned PriorGeneration;
7745  unsigned InstanceBits;
7746  unsigned FactoryBits;
7747  bool InstanceHasMoreThanOneDecl;
7748  bool FactoryHasMoreThanOneDecl;
7749  SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7750  SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
7751 
7752  public:
7754  unsigned PriorGeneration)
7755  : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
7756  InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false),
7757  FactoryHasMoreThanOneDecl(false) {}
7758 
7759  bool operator()(ModuleFile &M) {
7760  if (!M.SelectorLookupTable)
7761  return false;
7762 
7763  // If we've already searched this module file, skip it now.
7764  if (M.Generation <= PriorGeneration)
7765  return true;
7766 
7767  ++Reader.NumMethodPoolTableLookups;
7768  ASTSelectorLookupTable *PoolTable
7770  ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
7771  if (Pos == PoolTable->end())
7772  return false;
7773 
7774  ++Reader.NumMethodPoolTableHits;
7775  ++Reader.NumSelectorsRead;
7776  // FIXME: Not quite happy with the statistics here. We probably should
7777  // disable this tracking when called via LoadSelector.
7778  // Also, should entries without methods count as misses?
7779  ++Reader.NumMethodPoolEntriesRead;
7781  if (Reader.DeserializationListener)
7782  Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
7783 
7784  InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7785  FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7786  InstanceBits = Data.InstanceBits;
7787  FactoryBits = Data.FactoryBits;
7788  InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
7789  FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
7790  return true;
7791  }
7792 
7793  /// \brief Retrieve the instance methods found by this visitor.
7795  return InstanceMethods;
7796  }
7797 
7798  /// \brief Retrieve the instance methods found by this visitor.
7800  return FactoryMethods;
7801  }
7802 
7803  unsigned getInstanceBits() const { return InstanceBits; }
7804  unsigned getFactoryBits() const { return FactoryBits; }
7806  return InstanceHasMoreThanOneDecl;
7807  }
7808  bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
7809  };
7810 
7811 } // end namespace serialization
7812 } // end namespace clang
7813 
7814 /// \brief Add the given set of methods to the method list.
7816  ObjCMethodList &List) {
7817  for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7818  S.addMethodToGlobalList(&List, Methods[I]);
7819  }
7820 }
7821 
7823  // Get the selector generation and update it to the current generation.
7824  unsigned &Generation = SelectorGeneration[Sel];
7825  unsigned PriorGeneration = Generation;
7826  Generation = getGeneration();
7827  SelectorOutOfDate[Sel] = false;
7828 
7829  // Search for methods defined with this selector.
7830  ++NumMethodPoolLookups;
7831  ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
7832  ModuleMgr.visit(Visitor);
7833 
7834  if (Visitor.getInstanceMethods().empty() &&
7835  Visitor.getFactoryMethods().empty())
7836  return;
7837 
7838  ++NumMethodPoolHits;
7839 
7840  if (!getSema())
7841  return;
7842 
7843  Sema &S = *getSema();
7844  Sema::GlobalMethodPool::iterator Pos
7845  = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
7846 
7847  Pos->second.first.setBits(Visitor.getInstanceBits());
7848  Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
7849  Pos->second.second.setBits(Visitor.getFactoryBits());
7850  Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
7851 
7852  // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
7853  // when building a module we keep every method individually and may need to
7854  // update hasMoreThanOneDecl as we add the methods.
7855  addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7856  addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
7857 }
7858 
7860  if (SelectorOutOfDate[Sel])
7861  ReadMethodPool(Sel);
7862 }
7863 
7865  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7866  Namespaces.clear();
7867 
7868  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7869  if (NamespaceDecl *Namespace
7870  = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7871  Namespaces.push_back(Namespace);
7872  }
7873 }
7874 
7876  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
7877  for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7878  NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
7879  SourceLocation Loc =
7880  SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
7881  Undefined.insert(std::make_pair(D, Loc));
7882  }
7883 }
7884 
7886  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
7887  Exprs) {
7888  for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
7889  FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
7890  uint64_t Count = DelayedDeleteExprs[Idx++];
7891  for (uint64_t C = 0; C < Count; ++C) {
7892  SourceLocation DeleteLoc =
7893  SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
7894  const bool IsArrayForm = DelayedDeleteExprs[Idx++];
7895  Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
7896  }
7897  }
7898 }
7899 
7901  SmallVectorImpl<VarDecl *> &TentativeDefs) {
7902  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
7903  VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
7904  if (Var)
7905  TentativeDefs.push_back(Var);
7906  }
7907  TentativeDefinitions.clear();
7908 }
7909 
7912  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
7913  DeclaratorDecl *D
7914  = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
7915  if (D)
7916  Decls.push_back(D);
7917  }
7918  UnusedFileScopedDecls.clear();
7919 }
7920 
7923  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
7925  = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
7926  if (D)
7927  Decls.push_back(D);
7928  }
7929  DelegatingCtorDecls.clear();
7930 }
7931 
7933  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
7934  TypedefNameDecl *D
7935  = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
7936  if (D)
7937  Decls.push_back(D);
7938  }
7939  ExtVectorDecls.clear();
7940 }
7941 
7944  for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
7945  ++I) {
7946  TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
7947  GetDecl(UnusedLocalTypedefNameCandidates[I]));
7948  if (D)
7949  Decls.insert(D);
7950  }
7951  UnusedLocalTypedefNameCandidates.clear();
7952 }
7953 
7955  SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7956  if (ReferencedSelectorsData.empty())
7957  return;
7958 
7959  // If there are @selector references added them to its pool. This is for
7960  // implementation of -Wselector.
7961  unsigned int DataSize = ReferencedSelectorsData.size()-1;
7962  unsigned I = 0;
7963  while (I < DataSize) {
7964  Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7965  SourceLocation SelLoc
7966  = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7967  Sels.push_back(std::make_pair(Sel, SelLoc));
7968  }
7969  ReferencedSelectorsData.clear();
7970 }
7971 
7973  SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7974  if (WeakUndeclaredIdentifiers.empty())
7975  return;
7976 
7977  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7978  IdentifierInfo *WeakId
7979  = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7980  IdentifierInfo *AliasId
7981  = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7982  SourceLocation Loc
7983  = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7984  bool Used = WeakUndeclaredIdentifiers[I++];
7985  WeakInfo WI(AliasId, Loc);
7986  WI.setUsed(Used);
7987  WeakIDs.push_back(std::make_pair(WeakId, WI));
7988  }
7989  WeakUndeclaredIdentifiers.clear();
7990 }
7991 
7993  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7994  ExternalVTableUse VT;
7995  VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7996  VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7997  VT.DefinitionRequired = VTableUses[Idx++];
7998  VTables.push_back(VT);
7999  }
8000 
8001  VTableUses.clear();
8002 }
8003 
8005  SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
8006  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8007  ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8008  SourceLocation Loc
8009  = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8010 
8011  Pending.push_back(std::make_pair(D, Loc));
8012  }
8013  PendingInstantiations.clear();
8014 }
8015 
8017  llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8018  &LPTMap) {
8019  for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8020  /* In loop */) {
8021  FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8022 
8023  auto LT = llvm::make_unique<LateParsedTemplate>();
8024  LT->D = GetDecl(LateParsedTemplates[Idx++]);
8025 
8026  ModuleFile *F = getOwningModuleFile(LT->D);
8027  assert(F && "No module");
8028 
8029  unsigned TokN = LateParsedTemplates[Idx++];
8030  LT->Toks.reserve(TokN);
8031  for (unsigned T = 0; T < TokN; ++T)
8032  LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8033 
8034  LPTMap.insert(std::make_pair(FD, std::move(LT)));
8035  }
8036 
8037  LateParsedTemplates.clear();
8038 }
8039 
8041  // It would be complicated to avoid reading the methods anyway. So don't.
8042  ReadMethodPool(Sel);
8043 }
8044 
8046  assert(ID && "Non-zero identifier ID required");
8047  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8048  IdentifiersLoaded[ID - 1] = II;
8049  if (DeserializationListener)
8050  DeserializationListener->IdentifierRead(ID, II);
8051 }
8052 
8053 /// \brief Set the globally-visible declarations associated with the given
8054 /// identifier.
8055 ///
8056 /// If the AST reader is currently in a state where the given declaration IDs
8057 /// cannot safely be resolved, they are queued until it is safe to resolve
8058 /// them.
8059 ///
8060 /// \param II an IdentifierInfo that refers to one or more globally-visible
8061 /// declarations.
8062 ///
8063 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8064 /// visible at global scope.
8065 ///
8066 /// \param Decls if non-null, this vector will be populated with the set of
8067 /// deserialized declarations. These declarations will not be pushed into
8068 /// scope.
8069 void
8071  const SmallVectorImpl<uint32_t> &DeclIDs,
8072  SmallVectorImpl<Decl *> *Decls) {
8073  if (NumCurrentElementsDeserializing && !Decls) {
8074  PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8075  return;
8076  }
8077 
8078  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8079  if (!SemaObj) {
8080  // Queue this declaration so that it will be added to the
8081  // translation unit scope and identifier's declaration chain
8082  // once a Sema object is known.
8083  PreloadedDeclIDs.push_back(DeclIDs[I]);
8084  continue;
8085  }
8086 
8087  NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8088 
8089  // If we're simply supposed to record the declarations, do so now.
8090  if (Decls) {
8091  Decls->push_back(D);
8092  continue;
8093  }
8094 
8095  // Introduce this declaration into the translation-unit scope
8096  // and add it to the declaration chain for this identifier, so
8097  // that (unqualified) name lookup will find it.
8098  pushExternalDeclIntoScope(D, II);
8099  }
8100 }
8101 
8103  if (ID == 0)
8104  return nullptr;
8105 
8106  if (IdentifiersLoaded.empty()) {
8107  Error("no identifier table in AST file");
8108  return nullptr;
8109  }
8110 
8111  ID -= 1;
8112  if (!IdentifiersLoaded[ID]) {
8113  GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8114  assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8115  ModuleFile *M = I->second;
8116  unsigned Index = ID - M->BaseIdentifierID;
8117  const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8118 
8119  // All of the strings in the AST file are preceded by a 16-bit length.
8120  // Extract that 16-bit length to avoid having to execute strlen().
8121  // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8122  // unsigned integers. This is important to avoid integer overflow when
8123  // we cast them to 'unsigned'.
8124  const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8125  unsigned StrLen = (((unsigned) StrLenPtr[0])
8126  | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8127  auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8128  IdentifiersLoaded[ID] = &II;
8129  markIdentifierFromAST(*this, II);
8130  if (DeserializationListener)
8131  DeserializationListener->IdentifierRead(ID + 1, &II);
8132  }
8133 
8134  return IdentifiersLoaded[ID];
8135 }
8136 
8137 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8138  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8139 }
8140 
8141 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8142  if (LocalID < NUM_PREDEF_IDENT_IDS)
8143  return LocalID;
8144 
8145  if (!M.ModuleOffsetMap.empty())
8146  ReadModuleOffsetMap(M);
8147 
8149  = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8150  assert(I != M.IdentifierRemap.end()
8151  && "Invalid index into identifier index remap");
8152 
8153  return LocalID + I->second;
8154 }
8155 
8157  if (ID == 0)
8158  return nullptr;
8159 
8160  if (MacrosLoaded.empty()) {
8161  Error("no macro table in AST file");
8162  return nullptr;
8163  }
8164 
8165  ID -= NUM_PREDEF_MACRO_IDS;
8166  if (!MacrosLoaded[ID]) {
8168  = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8169  assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8170  ModuleFile *M = I->second;
8171  unsigned Index = ID - M->BaseMacroID;
8172  MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8173 
8174  if (DeserializationListener)
8175  DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8176  MacrosLoaded[ID]);
8177  }
8178 
8179  return MacrosLoaded[ID];
8180 }
8181 
8182 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8183  if (LocalID < NUM_PREDEF_MACRO_IDS)
8184  return LocalID;
8185 
8186  if (!M.ModuleOffsetMap.empty())
8187  ReadModuleOffsetMap(M);
8188 
8190  = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8191  assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8192 
8193  return LocalID + I->second;
8194 }
8195 
8197 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8198  if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8199  return LocalID;
8200 
8201  if (!M.ModuleOffsetMap.empty())
8202  ReadModuleOffsetMap(M);
8203 
8205  = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8206  assert(I != M.SubmoduleRemap.end()
8207  && "Invalid index into submodule index remap");
8208 
8209  return LocalID + I->second;
8210 }
8211 
8213  if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8214  assert(GlobalID == 0 && "Unhandled global submodule ID");
8215  return nullptr;
8216  }
8217 
8218  if (GlobalID > SubmodulesLoaded.size()) {
8219  Error("submodule ID out of range in AST file");
8220  return nullptr;
8221  }
8222 
8223  return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8224 }
8225 
8227  return getSubmodule(ID);
8228 }
8229 
8230 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8231  if (ID & 1) {
8232  // It's a module, look it up by submodule ID.
8233  auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8234  return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8235  } else {
8236  // It's a prefix (preamble, PCH, ...). Look it up by index.
8237  unsigned IndexFromEnd = ID >> 1;
8238  assert(IndexFromEnd && "got reference to unknown module file");
8239  return getModuleManager().pch_modules().end()[-IndexFromEnd];
8240  }
8241 }
8242 
8243 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8244  if (!F)
8245  return 1;
8246 
8247  // For a file representing a module, use the submodule ID of the top-level
8248  // module as the file ID. For any other kind of file, the number of such
8249  // files loaded beforehand will be the same on reload.
8250  // FIXME: Is this true even if we have an explicit module file and a PCH?
8251  if (F->isModule())
8252  return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8253 
8254  auto PCHModules = getModuleManager().pch_modules();
8255  auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
8256  assert(I != PCHModules.end() && "emitting reference to unknown file");
8257  return (I - PCHModules.end()) << 1;
8258 }
8259 
8262  if (const Module *M = getSubmodule(ID))
8264 
8265  // If there is only a single PCH, return it instead.
8266  // Chained PCH are not supported.
8267  const auto &PCHChain = ModuleMgr.pch_modules();
8268  if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8269  ModuleFile &MF = ModuleMgr.getPrimaryModule();
8270  StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8271  StringRef FileName = llvm::sys::path::filename(MF.FileName);
8272  return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8273  MF.Signature);
8274  }
8275  return None;
8276 }
8277 
8279  auto I = BodySource.find(FD);
8280  if (I == BodySource.end())
8281  return EK_ReplyHazy;
8282  return I->second ? EK_Never : EK_Always;
8283 }
8284 
8285 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8286  return DecodeSelector(getGlobalSelectorID(M, LocalID));
8287 }
8288 
8290  if (ID == 0)
8291  return Selector();
8292 
8293  if (ID > SelectorsLoaded.size()) {
8294  Error("selector ID out of range in AST file");
8295  return Selector();
8296  }
8297 
8298  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8299  // Load this selector from the selector table.
8300  GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8301  assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8302  ModuleFile &M = *I->second;
8303  ASTSelectorLookupTrait Trait(*this, M);
8304  unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8305  SelectorsLoaded[ID - 1] =
8306  Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8307  if (DeserializationListener)
8308  DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8309  }
8310 
8311  return SelectorsLoaded[ID - 1];
8312 }
8313 
8315  return DecodeSelector(ID);
8316 }
8317 
8319  // ID 0 (the null selector) is considered an external selector.
8320  return getTotalNumSelectors() + 1;
8321 }
8322 
8324 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8325  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8326  return LocalID;
8327 
8328  if (!M.ModuleOffsetMap.empty())
8329  ReadModuleOffsetMap(M);
8330 
8333  assert(I != M.SelectorRemap.end()
8334  && "Invalid index into selector index remap");
8335 
8336  return LocalID + I->second;
8337 }
8338 
8341  const RecordData &Record, unsigned &Idx) {
8342  ASTContext &Context = getContext();
8344  switch (Kind) {
8346  return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8347 
8351  return DeclarationName(ReadSelector(F, Record, Idx));
8352 
8354  return Context.DeclarationNames.getCXXConstructorName(
8355  Context.getCanonicalType(readType(F, Record, Idx)));
8356 
8358  return Context.DeclarationNames.getCXXDestructorName(
8359  Context.getCanonicalType(readType(F, Record, Idx)));
8360 
8363  ReadDeclAs<TemplateDecl>(F, Record, Idx));
8364 
8367  Context.getCanonicalType(readType(F, Record, Idx)));
8368 
8370  return Context.DeclarationNames.getCXXOperatorName(
8371  (OverloadedOperatorKind)Record[Idx++]);
8372 
8375  GetIdentifierInfo(F, Record, Idx));
8376 
8379  }
8380 
8381  llvm_unreachable("Invalid NameKind!");
8382 }
8383 
8385  DeclarationNameLoc &DNLoc,
8386  DeclarationName Name,
8387  const RecordData &Record, unsigned &Idx) {
8388  switch (Name.getNameKind()) {
8392  DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8393  break;
8394 
8397  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8399  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8400  break;
8401 
8404  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8405  break;
8406 
8413  break;
8414  }
8415 }
8416 
8418  DeclarationNameInfo &NameInfo,
8419  const RecordData &Record, unsigned &Idx) {
8420  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8421  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8422  DeclarationNameLoc DNLoc;
8423  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8424  NameInfo.setInfo(DNLoc);
8425 }
8426 
8428  const RecordData &Record, unsigned &Idx) {
8429  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8430  unsigned NumTPLists = Record[Idx++];
8431  Info.NumTemplParamLists = NumTPLists;
8432  if (NumTPLists) {
8433  Info.TemplParamLists =
8434  new (getContext()) TemplateParameterList *[NumTPLists];
8435  for (unsigned i = 0; i != NumTPLists; ++i)
8436  Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8437  }
8438 }
8439 
8441 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8442  unsigned &Idx) {
8443  ASTContext &Context = getContext();
8445  switch (Kind) {
8447  return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8448 
8450  unsigned size = Record[Idx++];
8451  UnresolvedSet<8> Decls;
8452  while (size--)
8453  Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8454 
8455  return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8456  }
8457 
8459  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8460  bool hasTemplKeyword = Record[Idx++];
8461  TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8462  return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8463  }
8464 
8466  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8467  if (Record[Idx++]) // isIdentifier
8468  return Context.getDependentTemplateName(NNS,
8469  GetIdentifierInfo(F, Record,
8470  Idx));
8471  return Context.getDependentTemplateName(NNS,
8472  (OverloadedOperatorKind)Record[Idx++]);
8473  }
8474 
8477  = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8478  if (!param) return TemplateName();
8479  TemplateName replacement = ReadTemplateName(F, Record, Idx);
8480  return Context.getSubstTemplateTemplateParm(param, replacement);
8481  }
8482 
8485  = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8486  if (!Param)
8487  return TemplateName();
8488 
8489  TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8490  if (ArgPack.getKind() != TemplateArgument::Pack)
8491  return TemplateName();
8492 
8493  return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8494  }
8495  }
8496 
8497  llvm_unreachable("Unhandled template name kind!");
8498 }
8499 
8501  const RecordData &Record,
8502  unsigned &Idx,
8503  bool Canonicalize) {
8504  ASTContext &Context = getContext();
8505  if (Canonicalize) {
8506  // The caller wants a canonical template argument. Sometimes the AST only
8507  // wants template arguments in canonical form (particularly as the template
8508  // argument lists of template specializations) so ensure we preserve that
8509  // canonical form across serialization.
8510  TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8511  return Context.getCanonicalTemplateArgument(Arg);
8512  }
8513 
8515  switch (Kind) {
8517  return TemplateArgument();
8519  return TemplateArgument(readType(F, Record, Idx));
8521  ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8522  return TemplateArgument(D, readType(F, Record, Idx));
8523  }
8525  return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8527  llvm::APSInt Value = ReadAPSInt(Record, Idx);
8528  QualType T = readType(F, Record, Idx);
8529  return TemplateArgument(Context, Value, T);
8530  }
8532  return TemplateArgument(ReadTemplateName(F, Record, Idx));
8534  TemplateName Name = ReadTemplateName(F, Record, Idx);
8535  Optional<unsigned> NumTemplateExpansions;
8536  if (unsigned NumExpansions = Record[Idx++])
8537  NumTemplateExpansions = NumExpansions - 1;
8538  return TemplateArgument(Name, NumTemplateExpansions);
8539  }
8541  return TemplateArgument(ReadExpr(F));
8542  case TemplateArgument::Pack: {
8543  unsigned NumArgs = Record[Idx++];
8544  TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8545  for (unsigned I = 0; I != NumArgs; ++I)
8546  Args[I] = ReadTemplateArgument(F, Record, Idx);
8547  return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8548  }
8549  }
8550 
8551  llvm_unreachable("Unhandled template argument kind!");
8552 }
8553 
8556  const RecordData &Record, unsigned &Idx) {
8557  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8558  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8559  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8560 
8561  unsigned NumParams = Record[Idx++];
8563  Params.reserve(NumParams);
8564  while (NumParams--)
8565  Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8566 
8567  // TODO: Concepts
8569  getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8570  return TemplateParams;
8571 }
8572 
8573 void
8576  ModuleFile &F, const RecordData &Record,
8577  unsigned &Idx, bool Canonicalize) {
8578  unsigned NumTemplateArgs = Record[Idx++];
8579  TemplArgs.reserve(NumTemplateArgs);
8580  while (NumTemplateArgs--)
8581  TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8582 }
8583 
8584 /// \brief Read a UnresolvedSet structure.
8586  const RecordData &Record, unsigned &Idx) {
8587  unsigned NumDecls = Record[Idx++];
8588  Set.reserve(getContext(), NumDecls);
8589  while (NumDecls--) {
8590  DeclID ID = ReadDeclID(F, Record, Idx);
8591  AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8592  Set.addLazyDecl(getContext(), ID, AS);
8593  }
8594 }
8595 
8598  const RecordData &Record, unsigned &Idx) {
8599  bool isVirtual = static_cast<bool>(Record[Idx++]);
8600  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8601  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8602  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8603  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8604  SourceRange Range = ReadSourceRange(F, Record, Idx);
8605  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8606  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8607  EllipsisLoc);
8608  Result.setInheritConstructors(inheritConstructors);
8609  return Result;
8610 }
8611 
8613 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8614  unsigned &Idx) {
8615  ASTContext &Context = getContext();
8616  unsigned NumInitializers = Record[Idx++];
8617  assert(NumInitializers && "wrote ctor initializers but have no inits");
8618  auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8619  for (unsigned i = 0; i != NumInitializers; ++i) {
8620  TypeSourceInfo *TInfo = nullptr;
8621  bool IsBaseVirtual = false;
8622  FieldDecl *Member = nullptr;
8623  IndirectFieldDecl *IndirectMember = nullptr;
8624 
8625  CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8626  switch (Type) {
8627  case CTOR_INITIALIZER_BASE:
8628  TInfo = GetTypeSourceInfo(F, Record, Idx);
8629  IsBaseVirtual = Record[Idx++];
8630  break;
8631 
8633  TInfo = GetTypeSourceInfo(F, Record, Idx);
8634  break;
8635 
8637  Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8638  break;
8639 
8641  IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8642  break;
8643  }
8644 
8645  SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8646  Expr *Init = ReadExpr(F);
8647  SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8648  SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8649 
8650  CXXCtorInitializer *BOMInit;
8651  if (Type == CTOR_INITIALIZER_BASE)
8652  BOMInit = new (Context)
8653  CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8654  RParenLoc, MemberOrEllipsisLoc);
8655  else if (Type == CTOR_INITIALIZER_DELEGATING)
8656  BOMInit = new (Context)
8657  CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8658  else if (Member)
8659  BOMInit = new (Context)
8660  CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8661  Init, RParenLoc);
8662  else
8663  BOMInit = new (Context)
8664  CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8665  LParenLoc, Init, RParenLoc);
8666 
8667  if (/*IsWritten*/Record[Idx++]) {
8668  unsigned SourceOrder = Record[Idx++];
8669  BOMInit->setSourceOrder(SourceOrder);
8670  }
8671 
8672  CtorInitializers[i] = BOMInit;
8673  }
8674 
8675  return CtorInitializers;
8676 }
8677 
8680  const RecordData &Record, unsigned &Idx) {
8681  ASTContext &Context = getContext();
8682  unsigned N = Record[Idx++];
8683  NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8684  for (unsigned I = 0; I != N; ++I) {
8686  = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8687  switch (Kind) {
8689  IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8690  NNS = NestedNameSpecifier::Create(Context, Prev, II);
8691  break;
8692  }
8693 
8695  NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8696  NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8697  break;
8698  }
8699 
8701  NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8702  NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8703  break;
8704  }
8705 
8708  const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8709  if (!T)
8710  return nullptr;
8711 
8712  bool Template = Record[Idx++];
8713  NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8714  break;
8715  }
8716 
8718  NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8719  // No associated value, and there can't be a prefix.
8720  break;
8721  }
8722 
8724  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8725  NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8726  break;
8727  }
8728  }
8729  Prev = NNS;
8730  }
8731  return NNS;
8732 }
8733 
8736  unsigned &Idx) {
8737  ASTContext &Context = getContext();
8738  unsigned N = Record[Idx++];
8740  for (unsigned I = 0; I != N; ++I) {
8742  = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8743  switch (Kind) {
8745  IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8746  SourceRange Range = ReadSourceRange(F, Record, Idx);
8747  Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8748  break;
8749  }
8750 
8752  NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8753  SourceRange Range = ReadSourceRange(F, Record, Idx);
8754  Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8755  break;
8756  }
8757 
8759  NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8760  SourceRange Range = ReadSourceRange(F, Record, Idx);
8761  Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8762  break;
8763  }
8764 
8767  bool Template = Record[Idx++];
8768  TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
8769  if (!T)
8770  return NestedNameSpecifierLoc();
8771  SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8772 
8773  // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8774  Builder.Extend(Context,
8775  Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8776  T->getTypeLoc(), ColonColonLoc);
8777  break;
8778  }
8779 
8781  SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8782  Builder.MakeGlobal(Context, ColonColonLoc);
8783  break;
8784  }
8785 
8787  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8788  SourceRange Range = ReadSourceRange(F, Record, Idx);
8789  Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8790  break;
8791  }
8792  }
8793  }
8794 
8795  return Builder.getWithLocInContext(Context);
8796 }
8797 
8799 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8800  unsigned &Idx) {
8801  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8802  SourceLocation end = ReadSourceLocation(F, Record, Idx);
8803  return SourceRange(beg, end);
8804 }
8805 
8806 /// \brief Read an integral value
8807 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8808  unsigned BitWidth = Record[Idx++];
8809  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8810  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8811  Idx += NumWords;
8812  return Result;
8813 }
8814 
8815 /// \brief Read a signed integral value
8816 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8817  bool isUnsigned = Record[Idx++];
8818  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8819 }
8820 
8821 /// \brief Read a floating-point value
8822 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8823  const llvm::fltSemantics &Sem,
8824  unsigned &Idx) {
8825  return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8826 }
8827 
8828 // \brief Read a string
8829 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8830  unsigned Len = Record[Idx++];
8831  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8832  Idx += Len;
8833  return Result;
8834 }
8835 
8836 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
8837  unsigned &Idx) {
8838  std::string Filename = ReadString(Record, Idx);
8839  ResolveImportedPath(F, Filename);
8840  return Filename;
8841 }
8842 
8844  unsigned &Idx) {
8845  unsigned Major = Record[Idx++];
8846  unsigned Minor = Record[Idx++];
8847  unsigned Subminor = Record[Idx++];
8848  if (Minor == 0)
8849  return VersionTuple(Major);
8850  if (Subminor == 0)
8851  return VersionTuple(Major, Minor - 1);
8852  return VersionTuple(Major, Minor - 1, Subminor - 1);
8853 }
8854 
8856  const RecordData &Record,
8857  unsigned &Idx) {
8858  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8859  return CXXTemporary::Create(getContext(), Decl);
8860 }
8861 
8862 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
8863  return Diag(CurrentImportLoc, DiagID);
8864 }
8865 
8866 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
8867  return Diags.Report(Loc, DiagID);
8868 }
8869 
8870 /// \brief Retrieve the identifier table associated with the
8871 /// preprocessor.
8873  return PP.getIdentifierTable();
8874 }
8875 
8876 /// \brief Record that the given ID maps to the given switch-case
8877 /// statement.
8879  assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8880  "Already have a SwitchCase with this ID");
8881  (*CurrSwitchCaseStmts)[ID] = SC;
8882 }
8883 
8884 /// \brief Retrieve the switch-case statement with the given ID.
8886  assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8887  return (*CurrSwitchCaseStmts)[ID];
8888 }
8889 
8891  CurrSwitchCaseStmts->clear();
8892 }
8893 
8895  ASTContext &Context = getContext();
8896  std::vector<RawComment *> Comments;
8897  for (SmallVectorImpl<std::pair<BitstreamCursor,
8898  serialization::ModuleFile *> >::iterator
8899  I = CommentsCursors.begin(),
8900  E = CommentsCursors.end();
8901  I != E; ++I) {
8902  Comments.clear();
8903  BitstreamCursor &Cursor = I->first;
8904  serialization::ModuleFile &F = *I->second;
8905  SavedStreamPosition SavedPosition(Cursor);
8906 
8907  RecordData Record;
8908  while (true) {
8909  llvm::BitstreamEntry Entry =
8910  Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
8911 
8912  switch (Entry.Kind) {
8913  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8915  Error("malformed block record in AST file");
8916  return;
8917  case llvm::BitstreamEntry::EndBlock:
8918  goto NextCursor;
8919  case llvm::BitstreamEntry::Record:
8920  // The interesting case.
8921  break;
8922  }
8923 
8924  // Read a record.
8925  Record.clear();
8926  switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
8927  case COMMENTS_RAW_COMMENT: {
8928  unsigned Idx = 0;
8929  SourceRange SR = ReadSourceRange(F, Record, Idx);
8931  (RawComment::CommentKind) Record[Idx++];
8932  bool IsTrailingComment = Record[Idx++];
8933  bool IsAlmostTrailingComment = Record[Idx++];
8934  Comments.push_back(new (Context) RawComment(
8935  SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8937  break;
8938  }
8939  }
8940  }
8941  NextCursor:
8942  // De-serialized SourceLocations get negative FileIDs for other modules,
8943  // potentially invalidating the original order. Sort it again.
8944  std::sort(Comments.begin(), Comments.end(),
8945  BeforeThanCompare<RawComment>(SourceMgr));
8946  Context.Comments.addDeserializedComments(Comments);
8947  }
8948 }
8949 
8951  bool IncludeSystem, bool Complain,
8952  llvm::function_ref<void(const serialization::InputFile &IF,
8953  bool isSystem)> Visitor) {
8954  unsigned NumUserInputs = MF.NumUserInputFiles;
8955  unsigned NumInputs = MF.InputFilesLoaded.size();
8956  assert(NumUserInputs <= NumInputs);
8957  unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
8958  for (unsigned I = 0; I < N; ++I) {
8959  bool IsSystem = I >= NumUserInputs;
8960  InputFile IF = getInputFile(MF, I+1, Complain);
8961  Visitor(IF, IsSystem);
8962  }
8963 }
8964 
8967  llvm::function_ref<void(const FileEntry *FE)> Visitor) {
8968  unsigned NumInputs = MF.InputFilesLoaded.size();
8969  for (unsigned I = 0; I < NumInputs; ++I) {
8970  InputFileInfo IFI = readInputFileInfo(MF, I + 1);
8971  if (IFI.TopLevelModuleMap)
8972  // FIXME: This unnecessarily re-reads the InputFileInfo.
8973  if (auto *FE = getInputFile(MF, I + 1).getFile())
8974  Visitor(FE);
8975  }
8976 }
8977 
8979  // If we know the owning module, use it.
8980  if (Module *M = D->getImportedOwningModule())
8981  return M->getFullModuleName();
8982 
8983  // Otherwise, use the name of the top-level module the decl is within.
8984  if (ModuleFile *M = getOwningModuleFile(D))
8985  return M->ModuleName;
8986 
8987  // Not from a module.
8988  return "";
8989 }
8990 
8991 void ASTReader::finishPendingActions() {
8992  while (!PendingIdentifierInfos.empty() ||
8993  !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
8994  !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
8995  !PendingUpdateRecords.empty()) {
8996  // If any identifiers with corresponding top-level declarations have
8997  // been loaded, load those declarations now.
8998  typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8999  TopLevelDeclsMap;
9000  TopLevelDeclsMap TopLevelDecls;
9001 
9002  while (!PendingIdentifierInfos.empty()) {
9003  IdentifierInfo *II = PendingIdentifierInfos.back().first;
9004  SmallVector<uint32_t, 4> DeclIDs =
9005  std::move(PendingIdentifierInfos.back().second);
9006  PendingIdentifierInfos.pop_back();
9007 
9008  SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9009  }
9010 
9011  // For each decl chain that we wanted to complete while deserializing, mark
9012  // it as "still needs to be completed".
9013  for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9014  markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9015  }
9016  PendingIncompleteDeclChains.clear();
9017 
9018  // Load pending declaration chains.
9019  for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9020  loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
9021  PendingDeclChains.clear();
9022 
9023  // Make the most recent of the top-level declarations visible.
9024  for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9025  TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9026  IdentifierInfo *II = TLD->first;
9027  for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9028  pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9029  }
9030  }
9031 
9032  // Load any pending macro definitions.
9033  for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9034  IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9036  GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9037  // Initialize the macro history from chained-PCHs ahead of module imports.
9038  for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9039  ++IDIdx) {
9040  const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9041  if (!Info.M->isModule())
9042  resolvePendingMacro(II, Info);
9043  }
9044  // Handle module imports.
9045  for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9046  ++IDIdx) {
9047  const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9048  if (Info.M->isModule())
9049  resolvePendingMacro(II, Info);
9050  }
9051  }
9052  PendingMacroIDs.clear();
9053 
9054  // Wire up the DeclContexts for Decls that we delayed setting until
9055  // recursive loading is completed.
9056  while (!PendingDeclContextInfos.empty()) {
9057  PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9058  PendingDeclContextInfos.pop_front();
9059  DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9060  DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9061  Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9062  }
9063 
9064  // Perform any pending declaration updates.
9065  while (!PendingUpdateRecords.empty()) {
9066  auto Update = PendingUpdateRecords.pop_back_val();
9067  ReadingKindTracker ReadingKind(Read_Decl, *this);
9068  loadDeclUpdateRecords(Update);
9069  }
9070  }
9071 
9072  // At this point, all update records for loaded decls are in place, so any
9073  // fake class definitions should have become real.
9074  assert(PendingFakeDefinitionData.empty() &&
9075  "faked up a class definition but never saw the real one");
9076 
9077  // If we deserialized any C++ or Objective-C class definitions, any
9078  // Objective-C protocol definitions, or any redeclarable templates, make sure
9079  // that all redeclarations point to the definitions. Note that this can only
9080  // happen now, after the redeclaration chains have been fully wired.
9081  for (Decl *D : PendingDefinitions) {
9082  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9083  if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9084  // Make sure that the TagType points at the definition.
9085  const_cast<TagType*>(TagT)->decl = TD;
9086  }
9087 
9088  if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9089  for (auto *R = getMostRecentExistingDecl(RD); R;
9090  R = R->getPreviousDecl()) {
9091  assert((R == D) ==
9092  cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9093  "declaration thinks it's the definition but it isn't");
9094  cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9095  }
9096  }
9097 
9098  continue;
9099  }
9100 
9101  if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9102  // Make sure that the ObjCInterfaceType points at the definition.
9103  const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9104  ->Decl = ID;
9105 
9106  for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9107  cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9108 
9109  continue;
9110  }
9111 
9112  if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9113  for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9114  cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9115 
9116  continue;
9117  }
9118 
9119  auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9120  for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9121  cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9122  }
9123  PendingDefinitions.clear();
9124 
9125  // Load the bodies of any functions or methods we've encountered. We do
9126  // this now (delayed) so that we can be sure that the declaration chains
9127  // have been fully wired up (hasBody relies on this).
9128  // FIXME: We shouldn't require complete redeclaration chains here.
9129  for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9130  PBEnd = PendingBodies.end();
9131  PB != PBEnd; ++PB) {
9132  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9133  // FIXME: Check for =delete/=default?
9134  // FIXME: Complain about ODR violations here?
9135  const FunctionDecl *Defn = nullptr;
9136  if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9137  FD->setLazyBody(PB->second);
9138  } else
9139  mergeDefinitionVisibility(const_cast<FunctionDecl*>(Defn), FD);
9140  continue;
9141  }
9142 
9143  ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9144  if (!getContext().getLangOpts().Modules || !MD->hasBody())
9145  MD->setLazyBody(PB->second);
9146  }
9147  PendingBodies.clear();
9148 
9149  // Do some cleanup.
9150  for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9152  PendingMergedDefinitionsToDeduplicate.clear();
9153 }
9154 
9155 void ASTReader::diagnoseOdrViolations() {
9156  if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
9157  return;
9158 
9159  // Trigger the import of the full definition of each class that had any
9160  // odr-merging problems, so we can produce better diagnostics for them.
9161  // These updates may in turn find and diagnose some ODR failures, so take
9162  // ownership of the set first.
9163  auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9164  PendingOdrMergeFailures.clear();
9165  for (auto &Merge : OdrMergeFailures) {
9166  Merge.first->buildLookup();
9167  Merge.first->decls_begin();
9168  Merge.first->bases_begin();
9169  Merge.first->vbases_begin();
9170  for (auto *RD : Merge.second) {
9171  RD->decls_begin();
9172  RD->bases_begin();
9173  RD->vbases_begin();
9174  }
9175  }
9176 
9177  // For each declaration from a merged context, check that the canonical
9178  // definition of that context also contains a declaration of the same
9179  // entity.
9180  //
9181  // Caution: this loop does things that might invalidate iterators into
9182  // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9183  while (!PendingOdrMergeChecks.empty()) {
9184  NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9185 
9186  // FIXME: Skip over implicit declarations for now. This matters for things
9187  // like implicitly-declared special member functions. This isn't entirely
9188  // correct; we can end up with multiple unmerged declarations of the same
9189  // implicit entity.
9190  if (D->isImplicit())
9191  continue;
9192 
9193  DeclContext *CanonDef = D->getDeclContext();
9194 
9195  bool Found = false;
9196  const Decl *DCanon = D->getCanonicalDecl();
9197 
9198  for (auto RI : D->redecls()) {
9199  if (RI->getLexicalDeclContext() == CanonDef) {
9200  Found = true;
9201  break;
9202  }
9203  }
9204  if (Found)
9205  continue;
9206 
9207  // Quick check failed, time to do the slow thing. Note, we can't just
9208  // look up the name of D in CanonDef here, because the member that is
9209  // in CanonDef might not be found by name lookup (it might have been
9210  // replaced by a more recent declaration in the lookup table), and we
9211  // can't necessarily find it in the redeclaration chain because it might
9212  // be merely mergeable, not redeclarable.
9214  for (auto *CanonMember : CanonDef->decls()) {
9215  if (CanonMember->getCanonicalDecl() == DCanon) {
9216  // This can happen if the declaration is merely mergeable and not
9217  // actually redeclarable (we looked for redeclarations earlier).
9218  //
9219  // FIXME: We should be able to detect this more efficiently, without
9220  // pulling in all of the members of CanonDef.
9221  Found = true;
9222  break;
9223  }
9224  if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9225  if (ND->getDeclName() == D->getDeclName())
9226  Candidates.push_back(ND);
9227  }
9228 
9229  if (!Found) {
9230  // The AST doesn't like TagDecls becoming invalid after they've been
9231  // completed. We only really need to mark FieldDecls as invalid here.
9232  if (!isa<TagDecl>(D))
9233  D->setInvalidDecl();
9234 
9235  // Ensure we don't accidentally recursively enter deserialization while
9236  // we're producing our diagnostic.
9237  Deserializing RecursionGuard(this);
9238 
9239  std::string CanonDefModule =
9240  getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9241  Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9243  << CanonDef << CanonDefModule.empty() << CanonDefModule;
9244 
9245  if (Candidates.empty())
9246  Diag(cast<Decl>(CanonDef)->getLocation(),
9247  diag::note_module_odr_violation_no_possible_decls) << D;
9248  else {
9249  for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9250  Diag(Candidates[I]->getLocation(),
9251  diag::note_module_odr_violation_possible_decl)
9252  << Candidates[I];
9253  }
9254 
9255  DiagnosedOdrMergeFailures.insert(CanonDef);
9256  }
9257  }
9258 
9259  if (OdrMergeFailures.empty())
9260  return;
9261 
9262  // Ensure we don't accidentally recursively enter deserialization while
9263  // we're producing our diagnostics.
9264  Deserializing RecursionGuard(this);
9265 
9266  // Issue any pending ODR-failure diagnostics.
9267  for (auto &Merge : OdrMergeFailures) {
9268  // If we've already pointed out a specific problem with this class, don't
9269  // bother issuing a general "something's different" diagnostic.
9270  if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9271  continue;
9272 
9273  bool Diagnosed = false;
9274  CXXRecordDecl *FirstRecord = Merge.first;
9275  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9276  for (CXXRecordDecl *SecondRecord : Merge.second) {
9277  // Multiple different declarations got merged together; tell the user
9278  // where they came from.
9279  if (FirstRecord == SecondRecord)
9280  continue;
9281 
9282  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9283  using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9284  DeclHashes FirstHashes;
9285  DeclHashes SecondHashes;
9286  ODRHash Hash;
9287 
9288  auto PopulateHashes = [&Hash, FirstRecord](DeclHashes &Hashes,
9289  CXXRecordDecl *Record) {
9290  for (auto *D : Record->decls()) {
9291  // Due to decl merging, the first CXXRecordDecl is the parent of
9292  // Decls in both records.
9293  if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
9294  continue;
9295  Hash.clear();
9296  Hash.AddSubDecl(D);
9297  Hashes.emplace_back(D, Hash.CalculateHash());
9298  }
9299  };
9300  PopulateHashes(FirstHashes, FirstRecord);
9301  PopulateHashes(SecondHashes, SecondRecord);
9302 
9303  // Used with err_module_odr_violation_mismatch_decl and
9304  // note_module_odr_violation_mismatch_decl
9305  // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
9306  enum {
9307  EndOfClass,
9308  PublicSpecifer,
9309  PrivateSpecifer,
9310  ProtectedSpecifer,
9311  StaticAssert,
9312  Field,
9313  CXXMethod,
9314  TypeAlias,
9315  TypeDef,
9316  Var,
9317  Friend,
9318  Other
9319  } FirstDiffType = Other,
9320  SecondDiffType = Other;
9321 
9322  auto DifferenceSelector = [](Decl *D) {
9323  assert(D && "valid Decl required");
9324  switch (D->getKind()) {
9325  default:
9326  return Other;
9327  case Decl::AccessSpec:
9328  switch (D->getAccess()) {
9329  case AS_public:
9330  return PublicSpecifer;
9331  case AS_private:
9332  return PrivateSpecifer;
9333  case AS_protected:
9334  return ProtectedSpecifer;
9335  case AS_none:
9336  break;
9337  }
9338  llvm_unreachable("Invalid access specifier");
9339  case Decl::StaticAssert:
9340  return StaticAssert;
9341  case Decl::Field:
9342  return Field;
9343  case Decl::CXXMethod:
9344  case Decl::CXXConstructor:
9345  case Decl::CXXDestructor:
9346  return CXXMethod;
9347  case Decl::TypeAlias:
9348  return TypeAlias;
9349  case Decl::Typedef:
9350  return TypeDef;
9351  case Decl::Var:
9352  return Var;
9353  case Decl::Friend:
9354  return Friend;
9355  }
9356  };
9357 
9358  Decl *FirstDecl = nullptr;
9359  Decl *SecondDecl = nullptr;
9360  auto FirstIt = FirstHashes.begin();
9361  auto SecondIt = SecondHashes.begin();
9362 
9363  // If there is a diagnoseable difference, FirstDiffType and
9364  // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
9365  // filled in if not EndOfClass.
9366  while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
9367  if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
9368  FirstIt->second == SecondIt->second) {
9369  ++FirstIt;
9370  ++SecondIt;
9371  continue;
9372  }
9373 
9374  FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
9375  SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
9376 
9377  FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
9378  SecondDiffType =
9379  SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
9380 
9381  break;
9382  }
9383 
9384  if (FirstDiffType == Other || SecondDiffType == Other) {
9385  // Reaching this point means an unexpected Decl was encountered
9386  // or no difference was detected. This causes a generic error
9387  // message to be emitted.
9388  Diag(FirstRecord->getLocation(),
9389  diag::err_module_odr_violation_different_definitions)
9390  << FirstRecord << FirstModule.empty() << FirstModule;
9391 
9392  if (FirstDecl) {
9393  Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
9394  << FirstRecord << FirstDecl->getSourceRange();
9395  }
9396 
9397  Diag(SecondRecord->getLocation(),
9398  diag::note_module_odr_violation_different_definitions)
9399  << SecondModule;
9400 
9401  if (SecondDecl) {
9402  Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
9403  << SecondDecl->getSourceRange();
9404  }
9405 
9406  Diagnosed = true;
9407  break;
9408  }
9409 
9410  if (FirstDiffType != SecondDiffType) {
9411  SourceLocation FirstLoc;
9412  SourceRange FirstRange;
9413  if (FirstDiffType == EndOfClass) {
9414  FirstLoc = FirstRecord->getBraceRange().getEnd();
9415  } else {
9416  FirstLoc = FirstIt->first->getLocation();
9417  FirstRange = FirstIt->first->getSourceRange();
9418  }
9419  Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
9420  << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
9421  << FirstDiffType;
9422 
9423  SourceLocation SecondLoc;
9424  SourceRange SecondRange;
9425  if (SecondDiffType == EndOfClass) {
9426  SecondLoc = SecondRecord->getBraceRange().getEnd();
9427  } else {
9428  SecondLoc = SecondDecl->getLocation();
9429  SecondRange = SecondDecl->getSourceRange();
9430  }
9431  Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
9432  << SecondModule << SecondRange << SecondDiffType;
9433  Diagnosed = true;
9434  break;
9435  }
9436 
9437  assert(FirstDiffType == SecondDiffType);
9438 
9439  // Used with err_module_odr_violation_mismatch_decl_diff and
9440  // note_module_odr_violation_mismatch_decl_diff
9441  enum ODRDeclDifference{
9442  StaticAssertCondition,
9443  StaticAssertMessage,
9444  StaticAssertOnlyMessage,
9445  FieldName,
9446  FieldTypeName,
9447  FieldSingleBitField,
9448  FieldDifferentWidthBitField,
9449  FieldSingleMutable,
9450  FieldSingleInitializer,
9451  FieldDifferentInitializers,
9452  MethodName,
9453  MethodDeleted,
9454  MethodVirtual,
9455  MethodStatic,
9456  MethodVolatile,
9457  MethodConst,
9458  MethodInline,
9459  MethodNumberParameters,
9460  MethodParameterType,
9461  MethodParameterName,
9462  MethodParameterSingleDefaultArgument,
9463  MethodParameterDifferentDefaultArgument,
9464  TypedefName,
9465  TypedefType,
9466  VarName,
9467  VarType,
9468  VarSingleInitializer,
9469  VarDifferentInitializer,
9470  VarConstexpr,
9471  FriendTypeFunction,
9472  FriendType,
9473  FriendFunction,
9474  };
9475 
9476  // These lambdas have the common portions of the ODR diagnostics. This
9477  // has the same return as Diag(), so addition parameters can be passed
9478  // in with operator<<
9479  auto ODRDiagError = [FirstRecord, &FirstModule, this](
9480  SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
9481  return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
9482  << FirstRecord << FirstModule.empty() << FirstModule << Range
9483  << DiffType;
9484  };
9485  auto ODRDiagNote = [&SecondModule, this](
9486  SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
9487  return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
9488  << SecondModule << Range << DiffType;
9489  };
9490 
9491  auto ComputeODRHash = [&Hash](const Stmt* S) {
9492  assert(S);
9493  Hash.clear();
9494  Hash.AddStmt(S);
9495  return Hash.CalculateHash();
9496  };
9497 
9498  auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9499  Hash.clear();
9500  Hash.AddQualType(Ty);
9501  return Hash.CalculateHash();
9502  };
9503 
9504  switch (FirstDiffType) {
9505  case Other:
9506  case EndOfClass:
9507  case PublicSpecifer:
9508  case PrivateSpecifer:
9509  case ProtectedSpecifer:
9510  llvm_unreachable("Invalid diff type");
9511 
9512  case StaticAssert: {
9513  StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
9514  StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
9515 
9516  Expr *FirstExpr = FirstSA->getAssertExpr();
9517  Expr *SecondExpr = SecondSA->getAssertExpr();
9518  unsigned FirstODRHash = ComputeODRHash(FirstExpr);
9519  unsigned SecondODRHash = ComputeODRHash(SecondExpr);
9520  if (FirstODRHash != SecondODRHash) {
9521  ODRDiagError(FirstExpr->getLocStart(), FirstExpr->getSourceRange(),
9522  StaticAssertCondition);
9523  ODRDiagNote(SecondExpr->getLocStart(),
9524  SecondExpr->getSourceRange(), StaticAssertCondition);
9525  Diagnosed = true;
9526  break;
9527  }
9528 
9529  StringLiteral *FirstStr = FirstSA->getMessage();
9530  StringLiteral *SecondStr = SecondSA->getMessage();
9531  assert((FirstStr || SecondStr) && "Both messages cannot be empty");
9532  if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
9533  SourceLocation FirstLoc, SecondLoc;
9534  SourceRange FirstRange, SecondRange;
9535  if (FirstStr) {
9536  FirstLoc = FirstStr->getLocStart();
9537  FirstRange = FirstStr->getSourceRange();
9538  } else {
9539  FirstLoc = FirstSA->getLocStart();
9540  FirstRange = FirstSA->getSourceRange();
9541  }
9542  if (SecondStr) {
9543  SecondLoc = SecondStr->getLocStart();
9544  SecondRange = SecondStr->getSourceRange();
9545  } else {
9546  SecondLoc = SecondSA->getLocStart();
9547  SecondRange = SecondSA->getSourceRange();
9548  }
9549  ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
9550  << (FirstStr == nullptr);
9551  ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
9552  << (SecondStr == nullptr);
9553  Diagnosed = true;
9554  break;
9555  }
9556 
9557  if (FirstStr && SecondStr &&
9558  FirstStr->getString() != SecondStr->getString()) {
9559  ODRDiagError(FirstStr->getLocStart(), FirstStr->getSourceRange(),
9560  StaticAssertMessage);
9561  ODRDiagNote(SecondStr->getLocStart(), SecondStr->getSourceRange(),
9562  StaticAssertMessage);
9563  Diagnosed = true;
9564  break;
9565  }
9566  break;
9567  }
9568  case Field: {
9569  FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
9570  FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
9571  IdentifierInfo *FirstII = FirstField->getIdentifier();
9572  IdentifierInfo *SecondII = SecondField->getIdentifier();
9573  if (FirstII->getName() != SecondII->getName()) {
9574  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
9575  FieldName)
9576  << FirstII;
9577  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
9578  FieldName)
9579  << SecondII;
9580 
9581  Diagnosed = true;
9582  break;
9583  }
9584 
9585  assert(getContext().hasSameType(FirstField->getType(),
9586  SecondField->getType()));
9587 
9588  QualType FirstType = FirstField->getType();
9589  QualType SecondType = SecondField->getType();
9590  if (ComputeQualTypeODRHash(FirstType) !=
9591  ComputeQualTypeODRHash(SecondType)) {
9592  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
9593  FieldTypeName)
9594  << FirstII << FirstType;
9595  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
9596  FieldTypeName)
9597  << SecondII << SecondType;
9598 
9599  Diagnosed = true;
9600  break;
9601  }
9602 
9603  const bool IsFirstBitField = FirstField->isBitField();
9604  const bool IsSecondBitField = SecondField->isBitField();
9605  if (IsFirstBitField != IsSecondBitField) {
9606  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
9607  FieldSingleBitField)
9608  << FirstII << IsFirstBitField;
9609  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
9610  FieldSingleBitField)
9611  << SecondII << IsSecondBitField;
9612  Diagnosed = true;
9613  break;
9614  }
9615 
9616  if (IsFirstBitField && IsSecondBitField) {
9617  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
9618  FieldDifferentWidthBitField)
9619  << FirstII << FirstField->getBitWidth()->getSourceRange();
9620  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
9621  FieldDifferentWidthBitField)
9622  << SecondII << SecondField->getBitWidth()->getSourceRange();
9623  Diagnosed = true;
9624  break;
9625  }
9626 
9627  const bool IsFirstMutable = FirstField->isMutable();
9628  const bool IsSecondMutable = SecondField->isMutable();
9629  if (IsFirstMutable != IsSecondMutable) {
9630  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
9631  FieldSingleMutable)
9632  << FirstII << IsFirstMutable;
9633  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
9634  FieldSingleMutable)
9635  << SecondII << IsSecondMutable;
9636  Diagnosed = true;
9637  break;
9638  }
9639 
9640  const Expr *FirstInitializer = FirstField->getInClassInitializer();
9641  const Expr *SecondInitializer = SecondField->getInClassInitializer();
9642  if ((!FirstInitializer && SecondInitializer) ||
9643  (FirstInitializer && !SecondInitializer)) {
9644  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
9645  FieldSingleInitializer)
9646  << FirstII << (FirstInitializer != nullptr);
9647  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
9648  FieldSingleInitializer)
9649  << SecondII << (SecondInitializer != nullptr);
9650  Diagnosed = true;
9651  break;
9652  }
9653 
9654  if (FirstInitializer && SecondInitializer) {
9655  unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
9656  unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
9657  if (FirstInitHash != SecondInitHash) {
9658  ODRDiagError(FirstField->getLocation(),
9659  FirstField->getSourceRange(),
9660  FieldDifferentInitializers)
9661  << FirstII << FirstInitializer->getSourceRange();
9662  ODRDiagNote(SecondField->getLocation(),
9663  SecondField->getSourceRange(),
9664  FieldDifferentInitializers)
9665  << SecondII << SecondInitializer->getSourceRange();
9666  Diagnosed = true;
9667  break;
9668  }
9669  }
9670 
9671  break;
9672  }
9673  case CXXMethod: {
9674  enum {
9675  DiagMethod,
9676  DiagConstructor,
9677  DiagDestructor,
9678  } FirstMethodType,
9679  SecondMethodType;
9680  auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
9681  if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
9682  if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
9683  return DiagMethod;
9684  };
9685  const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
9686  const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
9687  FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
9688  SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
9689  auto FirstName = FirstMethod->getDeclName();
9690  auto SecondName = SecondMethod->getDeclName();
9691  if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
9692  ODRDiagError(FirstMethod->getLocation(),
9693  FirstMethod->getSourceRange(), MethodName)
9694  << FirstMethodType << FirstName;
9695  ODRDiagNote(SecondMethod->getLocation(),
9696  SecondMethod->getSourceRange(), MethodName)
9697  << SecondMethodType << SecondName;
9698 
9699  Diagnosed = true;
9700  break;
9701  }
9702 
9703  const bool FirstDeleted = FirstMethod->isDeleted();
9704  const bool SecondDeleted = SecondMethod->isDeleted();
9705  if (FirstDeleted != SecondDeleted) {
9706  ODRDiagError(FirstMethod->getLocation(),
9707  FirstMethod->getSourceRange(), MethodDeleted)
9708  << FirstMethodType << FirstName << FirstDeleted;
9709 
9710  ODRDiagNote(SecondMethod->getLocation(),
9711  SecondMethod->getSourceRange(), MethodDeleted)
9712  << SecondMethodType << SecondName << SecondDeleted;
9713  Diagnosed = true;
9714  break;
9715  }
9716 
9717  const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
9718  const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
9719  const bool FirstPure = FirstMethod->isPure();
9720  const bool SecondPure = SecondMethod->isPure();
9721  if ((FirstVirtual || SecondVirtual) &&
9722  (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
9723  ODRDiagError(FirstMethod->getLocation(),
9724  FirstMethod->getSourceRange(), MethodVirtual)
9725  << FirstMethodType << FirstName << FirstPure << FirstVirtual;
9726  ODRDiagNote(SecondMethod->getLocation(),
9727  SecondMethod->getSourceRange(), MethodVirtual)
9728  << SecondMethodType << SecondName << SecondPure << SecondVirtual;
9729  Diagnosed = true;
9730  break;
9731  }
9732 
9733  // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
9734  // FirstDecl is the canonical Decl of SecondDecl, so the storage
9735  // class needs to be checked instead.
9736  const auto FirstStorage = FirstMethod->getStorageClass();
9737  const auto SecondStorage = SecondMethod->getStorageClass();
9738  const bool FirstStatic = FirstStorage == SC_Static;
9739  const bool SecondStatic = SecondStorage == SC_Static;
9740  if (FirstStatic != SecondStatic) {
9741  ODRDiagError(FirstMethod->getLocation(),
9742  FirstMethod->getSourceRange(), MethodStatic)
9743  << FirstMethodType << FirstName << FirstStatic;
9744  ODRDiagNote(SecondMethod->getLocation(),
9745  SecondMethod->getSourceRange(), MethodStatic)
9746  << SecondMethodType << SecondName << SecondStatic;
9747  Diagnosed = true;
9748  break;
9749  }
9750 
9751  const bool FirstVolatile = FirstMethod->isVolatile();
9752  const bool SecondVolatile = SecondMethod->isVolatile();
9753  if (FirstVolatile != SecondVolatile) {
9754  ODRDiagError(FirstMethod->getLocation(),
9755  FirstMethod->getSourceRange(), MethodVolatile)
9756  << FirstMethodType << FirstName << FirstVolatile;
9757  ODRDiagNote(SecondMethod->getLocation(),
9758  SecondMethod->getSourceRange(), MethodVolatile)
9759  << SecondMethodType << SecondName << SecondVolatile;
9760  Diagnosed = true;
9761  break;
9762  }
9763 
9764  const bool FirstConst = FirstMethod->isConst();
9765  const bool SecondConst = SecondMethod->isConst();
9766  if (FirstConst != SecondConst) {
9767  ODRDiagError(FirstMethod->getLocation(),
9768  FirstMethod->getSourceRange(), MethodConst)
9769  << FirstMethodType << FirstName << FirstConst;
9770  ODRDiagNote(SecondMethod->getLocation(),
9771  SecondMethod->getSourceRange(), MethodConst)
9772  << SecondMethodType << SecondName << SecondConst;
9773  Diagnosed = true;
9774  break;
9775  }
9776 
9777  const bool FirstInline = FirstMethod->isInlineSpecified();
9778  const bool SecondInline = SecondMethod->isInlineSpecified();
9779  if (FirstInline != SecondInline) {
9780  ODRDiagError(FirstMethod->getLocation(),
9781  FirstMethod->getSourceRange(), MethodInline)
9782  << FirstMethodType << FirstName << FirstInline;
9783  ODRDiagNote(SecondMethod->getLocation(),
9784  SecondMethod->getSourceRange(), MethodInline)
9785  << SecondMethodType << SecondName << SecondInline;
9786  Diagnosed = true;
9787  break;
9788  }
9789 
9790  const unsigned FirstNumParameters = FirstMethod->param_size();
9791  const unsigned SecondNumParameters = SecondMethod->param_size();
9792  if (FirstNumParameters != SecondNumParameters) {
9793  ODRDiagError(FirstMethod->getLocation(),
9794  FirstMethod->getSourceRange(), MethodNumberParameters)
9795  << FirstMethodType << FirstName << FirstNumParameters;
9796  ODRDiagNote(SecondMethod->getLocation(),
9797  SecondMethod->getSourceRange(), MethodNumberParameters)
9798  << SecondMethodType << SecondName << SecondNumParameters;
9799  Diagnosed = true;
9800  break;
9801  }
9802 
9803  // Need this status boolean to know when break out of the switch.
9804  bool ParameterMismatch = false;
9805  for (unsigned I = 0; I < FirstNumParameters; ++I) {
9806  const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
9807  const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
9808 
9809  QualType FirstParamType = FirstParam->getType();
9810  QualType SecondParamType = SecondParam->getType();
9811  if (FirstParamType != SecondParamType &&
9812  ComputeQualTypeODRHash(FirstParamType) !=
9813  ComputeQualTypeODRHash(SecondParamType)) {
9814  if (const DecayedType *ParamDecayedType =
9815  FirstParamType->getAs<DecayedType>()) {
9816  ODRDiagError(FirstMethod->getLocation(),
9817  FirstMethod->getSourceRange(), MethodParameterType)
9818  << FirstMethodType << FirstName << (I + 1) << FirstParamType
9819  << true << ParamDecayedType->getOriginalType();
9820  } else {
9821  ODRDiagError(FirstMethod->getLocation(),
9822  FirstMethod->getSourceRange(), MethodParameterType)
9823  << FirstMethodType << FirstName << (I + 1) << FirstParamType
9824  << false;
9825  }
9826 
9827  if (const DecayedType *ParamDecayedType =
9828  SecondParamType->getAs<DecayedType>()) {
9829  ODRDiagNote(SecondMethod->getLocation(),
9830  SecondMethod->getSourceRange(), MethodParameterType)
9831  << SecondMethodType << SecondName << (I + 1)
9832  << SecondParamType << true
9833  << ParamDecayedType->getOriginalType();
9834  } else {
9835  ODRDiagNote(SecondMethod->getLocation(),
9836  SecondMethod->getSourceRange(), MethodParameterType)
9837  << SecondMethodType << SecondName << (I + 1)
9838  << SecondParamType << false;
9839  }
9840  ParameterMismatch = true;
9841  break;
9842  }
9843 
9844  DeclarationName FirstParamName = FirstParam->getDeclName();
9845  DeclarationName SecondParamName = SecondParam->getDeclName();
9846  if (FirstParamName != SecondParamName) {
9847  ODRDiagError(FirstMethod->getLocation(),
9848  FirstMethod->getSourceRange(), MethodParameterName)
9849  << FirstMethodType << FirstName << (I + 1) << FirstParamName;
9850  ODRDiagNote(SecondMethod->getLocation(),
9851  SecondMethod->getSourceRange(), MethodParameterName)
9852  << SecondMethodType << SecondName << (I + 1) << SecondParamName;
9853  ParameterMismatch = true;
9854  break;
9855  }
9856 
9857  const Expr *FirstInit = FirstParam->getInit();
9858  const Expr *SecondInit = SecondParam->getInit();
9859  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
9860  ODRDiagError(FirstMethod->getLocation(),
9861  FirstMethod->getSourceRange(),
9862  MethodParameterSingleDefaultArgument)
9863  << FirstMethodType << FirstName << (I + 1)
9864  << (FirstInit == nullptr)
9865  << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
9866  ODRDiagNote(SecondMethod->getLocation(),
9867  SecondMethod->getSourceRange(),
9868  MethodParameterSingleDefaultArgument)
9869  << SecondMethodType << SecondName << (I + 1)
9870  << (SecondInit == nullptr)
9871  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
9872  ParameterMismatch = true;
9873  break;
9874  }
9875 
9876  if (FirstInit && SecondInit &&
9877  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
9878  ODRDiagError(FirstMethod->getLocation(),
9879  FirstMethod->getSourceRange(),
9880  MethodParameterDifferentDefaultArgument)
9881  << FirstMethodType << FirstName << (I + 1)
9882  << FirstInit->getSourceRange();
9883  ODRDiagNote(SecondMethod->getLocation(),
9884  SecondMethod->getSourceRange(),
9885  MethodParameterDifferentDefaultArgument)
9886  << SecondMethodType << SecondName << (I + 1)
9887  << SecondInit->getSourceRange();
9888  ParameterMismatch = true;
9889  break;
9890 
9891  }
9892  }
9893 
9894  if (ParameterMismatch) {
9895  Diagnosed = true;
9896  break;
9897  }
9898 
9899  break;
9900  }
9901  case TypeAlias:
9902  case TypeDef: {
9903  TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
9904  TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
9905  auto FirstName = FirstTD->getDeclName();
9906  auto SecondName = SecondTD->getDeclName();
9907  if (FirstName != SecondName) {
9908  ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
9909  TypedefName)
9910  << (FirstDiffType == TypeAlias) << FirstName;
9911  ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
9912  TypedefName)
9913  << (FirstDiffType == TypeAlias) << SecondName;
9914  Diagnosed = true;
9915  break;
9916  }
9917 
9918  QualType FirstType = FirstTD->getUnderlyingType();
9919  QualType SecondType = SecondTD->getUnderlyingType();
9920  if (ComputeQualTypeODRHash(FirstType) !=
9921  ComputeQualTypeODRHash(SecondType)) {
9922  ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
9923  TypedefType)
9924  << (FirstDiffType == TypeAlias) << FirstName << FirstType;
9925  ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
9926  TypedefType)
9927  << (FirstDiffType == TypeAlias) << SecondName << SecondType;
9928  Diagnosed = true;
9929  break;
9930  }
9931  break;
9932  }
9933  case Var: {
9934  VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
9935  VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
9936  auto FirstName = FirstVD->getDeclName();
9937  auto SecondName = SecondVD->getDeclName();
9938  if (FirstName != SecondName) {
9939  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
9940  VarName)
9941  << FirstName;
9942  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
9943  VarName)
9944  << SecondName;
9945  Diagnosed = true;
9946  break;
9947  }
9948 
9949  QualType FirstType = FirstVD->getType();
9950  QualType SecondType = SecondVD->getType();
9951  if (ComputeQualTypeODRHash(FirstType) !=
9952  ComputeQualTypeODRHash(SecondType)) {
9953  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
9954  VarType)
9955  << FirstName << FirstType;
9956  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
9957  VarType)
9958  << SecondName << SecondType;
9959  Diagnosed = true;
9960  break;
9961  }
9962 
9963  const Expr *FirstInit = FirstVD->getInit();
9964  const Expr *SecondInit = SecondVD->getInit();
9965  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
9966  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
9967  VarSingleInitializer)
9968  << FirstName << (FirstInit == nullptr)
9969  << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
9970  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
9971  VarSingleInitializer)
9972  << SecondName << (SecondInit == nullptr)
9973  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
9974  Diagnosed = true;
9975  break;
9976  }
9977 
9978  if (FirstInit && SecondInit &&
9979  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
9980  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
9981  VarDifferentInitializer)
9982  << FirstName << FirstInit->getSourceRange();
9983  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
9984  VarDifferentInitializer)
9985  << SecondName << SecondInit->getSourceRange();
9986  Diagnosed = true;
9987  break;
9988  }
9989 
9990  const bool FirstIsConstexpr = FirstVD->isConstexpr();
9991  const bool SecondIsConstexpr = SecondVD->isConstexpr();
9992  if (FirstIsConstexpr != SecondIsConstexpr) {
9993  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
9994  VarConstexpr)
9995  << FirstName << FirstIsConstexpr;
9996  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
9997  VarConstexpr)
9998  << SecondName << SecondIsConstexpr;
9999  Diagnosed = true;
10000  break;
10001  }
10002  break;
10003  }
10004  case Friend: {
10005  FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10006  FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10007 
10008  NamedDecl *FirstND = FirstFriend->getFriendDecl();
10009  NamedDecl *SecondND = SecondFriend->getFriendDecl();
10010 
10011  TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10012  TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10013 
10014  if (FirstND && SecondND) {
10015  ODRDiagError(FirstFriend->getFriendLoc(),
10016  FirstFriend->getSourceRange(), FriendFunction)
10017  << FirstND;
10018  ODRDiagNote(SecondFriend->getFriendLoc(),
10019  SecondFriend->getSourceRange(), FriendFunction)
10020  << SecondND;
10021 
10022  Diagnosed = true;
10023  break;
10024  }
10025 
10026  if (FirstTSI && SecondTSI) {
10027  QualType FirstFriendType = FirstTSI->getType();
10028  QualType SecondFriendType = SecondTSI->getType();
10029  assert(ComputeQualTypeODRHash(FirstFriendType) !=
10030  ComputeQualTypeODRHash(SecondFriendType));
10031  ODRDiagError(FirstFriend->getFriendLoc(),
10032  FirstFriend->getSourceRange(), FriendType)
10033  << FirstFriendType;
10034  ODRDiagNote(SecondFriend->getFriendLoc(),
10035  SecondFriend->getSourceRange(), FriendType)
10036  << SecondFriendType;
10037  Diagnosed = true;
10038  break;
10039  }
10040 
10041  ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10042  FriendTypeFunction)
10043  << (FirstTSI == nullptr);
10044  ODRDiagNote(SecondFriend->getFriendLoc(),
10045  SecondFriend->getSourceRange(), FriendTypeFunction)
10046  << (SecondTSI == nullptr);
10047 
10048  Diagnosed = true;
10049  break;
10050  }
10051  }
10052 
10053  if (Diagnosed == true)
10054  continue;
10055 
10056  Diag(FirstDecl->getLocation(),
10057  diag::err_module_odr_violation_mismatch_decl_unknown)
10058  << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
10059  << FirstDecl->getSourceRange();
10060  Diag(SecondDecl->getLocation(),
10061  diag::note_module_odr_violation_mismatch_decl_unknown)
10062  << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
10063  Diagnosed = true;
10064  }
10065 
10066  if (!Diagnosed) {
10067  // All definitions are updates to the same declaration. This happens if a
10068  // module instantiates the declaration of a class template specialization
10069  // and two or more other modules instantiate its definition.
10070  //
10071  // FIXME: Indicate which modules had instantiations of this definition.
10072  // FIXME: How can this even happen?
10073  Diag(Merge.first->getLocation(),
10074  diag::err_module_odr_violation_different_instantiations)
10075  << Merge.first;
10076  }
10077  }
10078 }
10079 
10081  if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10082  ReadTimer->startTimer();
10083 }
10084 
10086  assert(NumCurrentElementsDeserializing &&
10087  "FinishedDeserializing not paired with StartedDeserializing");
10088  if (NumCurrentElementsDeserializing == 1) {
10089  // We decrease NumCurrentElementsDeserializing only after pending actions
10090  // are finished, to avoid recursively re-calling finishPendingActions().
10091  finishPendingActions();
10092  }
10093  --NumCurrentElementsDeserializing;
10094 
10095  if (NumCurrentElementsDeserializing == 0) {
10096  // Propagate exception specification updates along redeclaration chains.
10097  while (!PendingExceptionSpecUpdates.empty()) {
10098  auto Updates = std::move(PendingExceptionSpecUpdates);
10099  PendingExceptionSpecUpdates.clear();
10100  for (auto Update : Updates) {
10101  ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
10102  auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
10103  auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
10104  if (auto *Listener = getContext().getASTMutationListener())
10105  Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
10106  for (auto *Redecl : Update.second->redecls())
10107  getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
10108  }
10109  }
10110 
10111  if (ReadTimer)
10112  ReadTimer->stopTimer();
10113 
10114  diagnoseOdrViolations();
10115 
10116  // We are not in recursive loading, so it's safe to pass the "interesting"
10117  // decls to the consumer.
10118  if (Consumer)
10119  PassInterestingDeclsToConsumer();
10120  }
10121 }
10122 
10123 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
10124  if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
10125  // Remove any fake results before adding any real ones.
10126  auto It = PendingFakeLookupResults.find(II);
10127  if (It != PendingFakeLookupResults.end()) {
10128  for (auto *ND : It->second)
10129  SemaObj->IdResolver.RemoveDecl(ND);
10130  // FIXME: this works around module+PCH performance issue.
10131  // Rather than erase the result from the map, which is O(n), just clear
10132  // the vector of NamedDecls.
10133  It->second.clear();
10134  }
10135  }
10136 
10137  if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
10138  SemaObj->TUScope->AddDecl(D);
10139  } else if (SemaObj->TUScope) {
10140  // Adding the decl to IdResolver may have failed because it was already in
10141  // (even though it was not added in scope). If it is already in, make sure
10142  // it gets in the scope as well.
10143  if (std::find(SemaObj->IdResolver.begin(Name),
10144  SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
10145  SemaObj->TUScope->AddDecl(D);
10146  }
10147 }
10148 
10149 ASTReader::ASTReader(Preprocessor &PP, ASTContext *Context,
10150  const PCHContainerReader &PCHContainerRdr,
10151  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10152  StringRef isysroot, bool DisableValidation,
10153  bool AllowASTWithCompilerErrors,
10154  bool AllowConfigurationMismatch, bool ValidateSystemInputs,
10155  bool UseGlobalIndex,
10156  std::unique_ptr<llvm::Timer> ReadTimer)
10157  : Listener(DisableValidation
10159  : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
10160  SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10161  PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10162  ContextObj(Context),
10163  ModuleMgr(PP.getFileManager(), PP.getPCMCache(), PCHContainerRdr),
10164  PCMCache(PP.getPCMCache()), DummyIdResolver(PP),
10165  ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
10166  DisableValidation(DisableValidation),
10167  AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10168  AllowConfigurationMismatch(AllowConfigurationMismatch),
10169  ValidateSystemInputs(ValidateSystemInputs),
10170  UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10171  SourceMgr.setExternalSLocEntrySource(this);
10172 
10173  for (const auto &Ext : Extensions) {
10174  auto BlockName = Ext->getExtensionMetadata().BlockName;
10175  auto Known = ModuleFileExtensions.find(BlockName);
10176  if (Known != ModuleFileExtensions.end()) {
10177  Diags.Report(diag::warn_duplicate_module_file_extension)
10178  << BlockName;
10179  continue;
10180  }
10181 
10182  ModuleFileExtensions.insert({BlockName, Ext});
10183  }
10184 }
10185 
10187  if (OwnsDeserializationListener)
10188  delete DeserializationListener;
10189 }
10190 
10192  return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
10193 }
10194 
10195 unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
10196  unsigned AbbrevID) {
10197  Idx = 0;
10198  Record.clear();
10199  return Cursor.readRecord(AbbrevID, Record);
10200 }
llvm::APInt ReadAPInt(const RecordData &Record, unsigned &Idx)
Read an integral value.
Definition: ASTReader.cpp:8807
Decl * GetExistingDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration.
Definition: ASTReader.cpp:7064
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:194
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
bool isPoisoned() const
Return true if this token has been poisoned.
void setSourceOrder(int Pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2284
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
SmallVector< std::pair< llvm::BitstreamCursor, serialization::ModuleFile * >, 8 > CommentsCursors
Cursors for comments blocks.
Definition: ASTReader.h:2245
Defines the clang::ASTContext interface.
static bool isAcceptableASTFile(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts, const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts, StringRef ExistingModuleCachePath)
Determine whether the given AST file is acceptable to load into a translation unit with the given lan...
Definition: ASTReader.cpp:4834
SourceLocation getEnd() const
const FileEntry * OrigEntry
Reference to the file entry representing this ContentCache.
void updateOutOfDateSelector(Selector Sel) override
Load the contents of the global method pool for a given selector if necessary.
Definition: ASTReader.cpp:7859
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Finds all the visible declarations with a given name.
Definition: ASTReader.cpp:7276
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
Definition: ASTReader.h:342
Record code for the preprocessor options table.
Definition: ASTBitCodes.h:322
std::vector< unsigned > PreloadIdentifierOffsets
Offsets of identifiers that we're going to preload within IdentifierTableData.
Definition: Module.h:281
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
Definition: Module.h:286
CanQualType LongLongTy
Definition: ASTContext.h:971
static const Decl * getCanonicalDecl(const Decl *D)
The client can handle an AST file that cannot load because it was built with a different version of C...
Definition: ASTReader.h:1453
void setInfo(const DeclarationNameLoc &Info)
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1618
ASTFileSignature Signature
The module signature.
Definition: Module.h:94
std::string Name
The name of this module.
Definition: Module.h:60
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Source range/offset of a preprocessed entity.
Definition: ASTBitCodes.h:166
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:441
std::vector< std::pair< std::string, bool > > Macros
IdentifierIterator * getIdentifiers() override
Retrieve an iterator into the set of all identifiers in all loaded AST files.
Definition: ASTReader.cpp:7725
void * IdentifierLookupTable
A pointer to an on-disk hash table of opaque type IdentifierHashTable.
Definition: Module.h:277
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
Definition: ASTContext.h:1624
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
Definition: ASTReader.cpp:158
CanQualType OCLQueueTy
Definition: ASTContext.h:988
Record code for potentially unused local typedef names.
Definition: ASTBitCodes.h:583
Record code for map of Objective-C class definition IDs to the ObjC categories in a module that are a...
Definition: ASTBitCodes.h:541
Smart pointer class that efficiently represents Objective-C method names.
static void updateModuleTimestamp(ModuleFile &MF)
Definition: ASTReader.cpp:3713
static hash_value_type ComputeHash(Selector Sel)
Definition: ASTReader.cpp:766
unsigned Length
SmallVector< UnresolvedHeaderDirective, 1 > MissingHeaders
Headers that are mentioned in the module map file but could not be found on the file system...
Definition: Module.h:172
static bool checkTargetOptions(const TargetOptions &TargetOpts, const TargetOptions &ExistingTargetOpts, DiagnosticsEngine *Diags, bool AllowCompatibleDifferences=true)
Compare the given set of target options against an existing set of target options.
Definition: ASTReader.cpp:331
A (possibly-)qualified type.
Definition: Type.h:616
static LLVM_DUMP_METHOD void dumpModuleIDMap(StringRef Name, const ContinuousRangeMap< Key, ModuleFile *, InitialCapacity > &Map)
Definition: ASTReader.cpp:7463
A PointerType record.
Definition: ASTBitCodes.h:854
virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines)
Receives the preprocessor options.
Definition: ASTReader.h:175
CtorInitializerType
The different kinds of data that can occur in a CtorInitializer.
Definition: ASTBitCodes.h:1574
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
void setChangedSinceDeserialization()
Note that this identifier has changed since it was loaded from an AST file.
void AddTokenToBody(const Token &Tok)
Add the specified token to the replacement text for the macro.
Definition: MacroInfo.h:242
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1308
NameKind
NameKind - The kind of name this object contains.
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
The macro directives history for a particular identifier.
Definition: ASTBitCodes.h:655
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
static bool startsWithASTFileMagic(BitstreamCursor &Stream)
Whether Stream starts with the AST/PCH file magic number 'CPCH'.
Definition: ASTReader.cpp:3993
void SetIdentifierInfo(unsigned ID, IdentifierInfo *II)
Definition: ASTReader.cpp:8045
unsigned ImplicitModuleMaps
Implicit module maps.
virtual bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden, bool isExplicitModule)
if needsInputFileVisitation returns true, this is called for each non-system input file of the AST Fi...
Definition: ASTReader.h:201
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
The (signed) 'long long' type.
Definition: ASTBitCodes.h:772
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2434
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)
This is called for each AST file loaded.
Definition: ASTReader.h:186
A simple structure that captures a vtable use for the purposes of the ExternalSemaSource.
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes...
Defines the clang::FileManager interface and associated types.
CXXBaseSpecifier * GetExternalCXXBaseSpecifiers(uint64_t Offset) override
Resolve the offset of a set of C++ base specifiers in the decl stream into an array of specifiers...
Definition: ASTReader.cpp:6930
Record code for the source manager line table information, which stores information about #line direc...
Definition: ASTBitCodes.h:537
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
virtual StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const =0
Returns the serialized AST inside the PCH container Buffer.
bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name)
Try to add the given declaration to the top level scope, if it (or a redeclaration of it) hasn't alre...
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
This header is part of the module (for layering purposes) but should be textually included...
Definition: ModuleMap.h:111
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
The 'bool' or '_Bool' type.
Definition: ASTBitCodes.h:746
std::string ModuleUserBuildPath
The directory used for a user build.
static SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
Definition: Sanitizers.h:83
CanQualType Char32Ty
Definition: ASTContext.h:970
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1804
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:2194
unsigned getHash() const
Compute a fingerprint of this key for use in on-disk hash table.
Definition: ASTReader.cpp:999
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1399
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
Definition: ASTBitCodes.h:840
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Definition: Type.h:1268
Stmt - This represents one statement.
Definition: Stmt.h:60
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1242
Optional< bool > isPreprocessedEntityInFileID(unsigned Index, FileID FID) override
Optionally returns true or false if the preallocated preprocessed entity with index Index came from f...
Definition: ASTReader.cpp:5524
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1588
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1537
void AddQualType(QualType T)
Definition: ODRHash.cpp:625
void setExceptionSpecRange(SourceRange R)
Definition: TypeLoc.h:1412
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:100
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
SourceLocation DirectImportLoc
The source location where the module was explicitly or implicitly imported in the local translation u...
Definition: Module.h:191
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "...
Definition: Module.h:212
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
ControlRecordTypes
Record types that occur within the control block.
Definition: ASTBitCodes.h:265
void addTopHeaderFilename(StringRef Filename)
Add a top-level header filename associated with this module.
Definition: Module.h:460
llvm::MemoryBuffer * Buffer
The memory buffer that stores the data associated with this AST file, owned by the PCMCache in the Mo...
Definition: Module.h:168
unsigned Generation
The generation of which this module file is a part.
Definition: Module.h:164
void ReadComments() override
Loads comments ranges.
Definition: ASTReader.cpp:8894
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
Definition: Module.h:330
C Language Family Type Representation.
Defines the SourceManager interface.
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:123
The 'unknown any' placeholder type.
Definition: ASTBitCodes.h:800
void setWrittenWidthSpec(TypeSpecifierWidth written)
Definition: TypeLoc.h:599
Microsoft's '__super' specifier, stored as a CXXRecordDecl* of the class it appeared in...
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
Definition: ASTContext.h:1648
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
Definition: ASTReader.cpp:136
The template argument is an expression, and we've not resolved it to one of the other forms yet...
Definition: TemplateBase.h:69
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
RawCommentList Comments
All comments in this translation unit.
Definition: ASTContext.h:676
DeclarationName getCXXConversionFunctionName(CanQualType Ty)
getCXXConversionFunctionName - Returns the name of a C++ conversion function for the given Type...
QualType getUnderlyingType() const
Definition: Decl.h:2727
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTReader.cpp:8212
unsigned size() const
Number of modules loaded.
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
Definition: ASTBitCodes.h:145
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
SmallVector< uint64_t, 4 > PreloadSLocEntries
SLocEntries that we're going to preload.
Definition: Module.h:246
Module * getCurrentModule()
Retrieves the module that we're currently building, if any.
std::string getTimestampFilename() const
Definition: Module.h:123
virtual void MacroRead(serialization::MacroID ID, MacroInfo *MI)
A macro was read from the AST file.
CanQualType ObjCBuiltinSelTy
Definition: ASTContext.h:982
RetTy Visit(TypeLoc TyLoc)
void VisitFunctionTypeLoc(FunctionTypeLoc)
Definition: ASTReader.cpp:6399
ModuleKind Kind
The type of this module.
Definition: Module.h:112
virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value)
Receives COUNTER value.
Definition: ASTReader.h:182
Defines the C++ template declaration subclasses.
Describes a source location entry (SLocEntry) for a macro expansion.
Definition: ASTBitCodes.h:633
Scope * TUScope
Translation Unit Scope - useful to Objective-C actions that need to lookup file scope declarations in...
Definition: Sema.h:784
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1590
std::vector< std::string > Includes
static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts, const PreprocessorOptions &ExistingPPOpts, DiagnosticsEngine *Diags, FileManager &FileMgr, std::string &SuggestedPredefines, const LangOptions &LangOpts, bool Validate=true)
Check the preprocessor options deserialized from the control block against the preprocessor options i...
Definition: ASTReader.cpp:586
An LValueReferenceType record.
Definition: ASTBitCodes.h:858
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:922
The placeholder type for builtin functions.
Definition: ASTBitCodes.h:814
void AddDecl(Decl *D)
Definition: Scope.h:275
Defines the clang::MacroInfo and clang::MacroDirective classes.
Defines types useful for describing an Objective-C runtime.
bool isHidden() const
Determine whether this declaration might be hidden from name lookup.
Definition: DeclBase.h:745
Specifies the submodules that are imported by this submodule.
Definition: ASTBitCodes.h:693
std::string ModuleName
The name of the module.
Definition: Module.h:118
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:981
A record that stores the set of declarations that are lexically stored within a given DeclContext...
Definition: ASTBitCodes.h:1110
The module file is out-of-date.
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
Definition: Module.h:458
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn't a simple identifier.
Specifies an umbrella directory.
Definition: ASTBitCodes.h:690
The base class of the type hierarchy.
Definition: Type.h:1303
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:63
IdentifierInfo * getLocalIdentifier(ModuleFile &M, unsigned LocalID)
Definition: ASTReader.cpp:8137
CanQualType LongTy
Definition: ASTContext.h:971
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
Definition: Module.h:420
void setHasLineDirectives()
Set the flag that indicates that this FileID has line table entries associated with it...
StringRef getOriginalSourceFile()
Retrieve the name of the original source file name for the primary module file.
Definition: ASTReader.h:1594
#define CHECK_TARGET_OPT(Field, Name)
A SubstTemplateTypeParmType record.
Definition: ASTBitCodes.h:896
QualType getRecordType(const RecordDecl *Decl) const
std::unique_ptr< llvm::MemoryBuffer > Buffer
Decl * GetDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: ASTReader.cpp:7089
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1205
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2020
void setFlag(TokenFlags Flag)
Set the specified flag.
Definition: Token.h:234
const Expr * getInit() const
Definition: Decl.h:1146
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:51
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:461
Wrapper for source info for typedefs.
Definition: TypeLoc.h:638
static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II)
Definition: ASTReader.cpp:875
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:94
A container of type source information.
Definition: Decl.h:62
Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expan...
uint64_t GlobalBitOffset
The global bit offset (or base) of this module.
Definition: Module.h:174
Record code for enabled OpenCL extensions.
Definition: ASTBitCodes.h:520
Record code for the module build directory.
Definition: ASTBitCodes.h:298
Floating point control options.
Definition: LangOptions.h:203
void * getAsOpaquePtr() const
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:1642
void makeModuleVisible(Module *Mod, Module::NameVisibilityKind NameVisibility, SourceLocation ImportLoc)
Make the entities in the given module and any of its (non-explicit) submodules visible to name lookup...
Definition: ASTReader.cpp:3615
An ElaboratedType record.
Definition: ASTBitCodes.h:894
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:306
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
Definition: Module.h:365
virtual void IdentifierRead(serialization::IdentID ID, IdentifierInfo *II)
An identifier was deserialized from the AST file.
An UnresolvedUsingType record.
Definition: ASTBitCodes.h:898
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
Wrapper for source info for pointers decayed from arrays and functions.
Definition: TypeLoc.h:1197
bool hasAttrEnumOperand() const
Definition: TypeLoc.h:841
ASTFileSignature Signature
The signature of the module file, which may be used instead of the size and modification time to iden...
Definition: Module.h:157
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2329
TypeLoc getNextTypeLoc() const
Definition: TypeLoc.h:382
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:68
An IncompleteArrayType record.
Definition: ASTBitCodes.h:866
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
The internal '__type_pack_element' template.
Definition: ASTBitCodes.h:1024
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:201
void addPendingMacro(IdentifierInfo *II, ModuleFile *M, uint64_t MacroDirectivesOffset)
Add a macro to deserialize its macro directive history.
Definition: ASTReader.cpp:1749
Expr * getInClassInitializer() const
getInClassInitializer - Get the C++11 in-class initializer for this member, or null if one has not be...
Definition: Decl.h:2489
Specifies a header that is part of the module but must be textually included.
Definition: ASTBitCodes.h:712
const uint32_t * SLocEntryOffsets
Offsets for all of the source location entries in the AST file.
Definition: Module.h:243
bool RelocatablePCH
Whether this precompiled header is a relocatable PCH file.
Definition: Module.h:147
CXXBaseSpecifier ReadCXXBaseSpecifier(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a C++ base specifier.
Definition: ASTReader.cpp:8597
ARC's unbridged-cast placeholder type.
Definition: ASTBitCodes.h:810
CanQualType HalfTy
Definition: ASTContext.h:975
DeclarationName getCXXDeductionGuideName(TemplateDecl *TD)
Returns the name of a C++ deduction guide for the given template.
The client can handle an AST file that cannot load because it is out-of-date relative to its input fi...
Definition: ASTReader.h:1450
The AST file has errors.
Definition: ASTReader.h:359
void visit(llvm::function_ref< bool(ModuleFile &M)> Visitor, llvm::SmallPtrSetImpl< ModuleFile * > *ModuleFilesHit=nullptr)
Visit each of the modules.
ArrayRef< ObjCMethodDecl * > getInstanceMethods() const
Retrieve the instance methods found by this visitor.
Definition: ASTReader.cpp:7794
bool getWarningsAsErrors() const
Definition: Diagnostic.h:525
uint32_t IdentifierID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:55
An identifier, stored as an IdentifierInfo*.
The internal '__builtin_va_list' typedef.
Definition: ASTBitCodes.h:1003
The stack of open #ifs/#ifdefs recorded in a preamble.
Definition: ASTBitCodes.h:612
void addRequirement(StringRef Feature, bool RequiredState, const LangOptions &LangOpts, const TargetInfo &Target)
Add the given feature requirement to the list of features required by this module.
Definition: Module.cpp:221
void getExportedModules(SmallVectorImpl< Module * > &Exported) const
Appends this module's list of exported modules to Exported.
Definition: Module.cpp:269
Manages the set of modules loaded by an AST reader.
Definition: ModuleManager.h:34
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:40
static Qualifiers fromOpaqueValue(unsigned opaque)
Definition: Type.h:226
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:758
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation > > &Sels) override
Read the set of referenced selectors known to the external Sema source.
Definition: ASTReader.cpp:7954
Record code for #pragma pack options.
Definition: ASTBitCodes.h:609
A block with unhashed content.
Definition: ASTBitCodes.h:261
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
std::string ImplicitPTHInclude
The implicit PTH input included at the start of the translation unit, or empty.
const FileEntry * getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:424
CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset) override
Read the contents of a CXXCtorInitializer array.
Definition: ASTReader.cpp:6911
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1265
void VisitArrayTypeLoc(ArrayTypeLoc)
Definition: ASTReader.cpp:6360
Options for controlling the target.
Definition: TargetOptions.h:26
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Definition: TypeLoc.h:254
serialization::TypeID getGlobalTypeID(ModuleFile &F, unsigned LocalID) const
Map a local type ID within a given AST file into a global type ID.
Definition: ASTReader.cpp:6774
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing)...
Definition: DiagnosticIDs.h:63
bool hasAttrExprOperand() const
Definition: TypeLoc.h:836
Record code for declarations associated with OpenCL extensions.
Definition: ASTBitCodes.h:604
void CompleteRedeclChain(const Decl *D) override
If any redeclarations of D have been imported since it was last checked, this digs out those redeclar...
Definition: ASTReader.cpp:6858
CanQualType Float128Ty
Definition: ASTContext.h:974
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:46
Extra information about a function prototype.
Definition: Type.h:3234
AccessSpecifier getAccess() const
Definition: DeclBase.h:451
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
Definition: ASTReader.cpp:7514
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
Definition: Module.h:348
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
Definition: ASTBitCodes.h:1031
The value of the next COUNTER to dispense.
Definition: ASTBitCodes.h:445
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
unsigned getLineTableFilenameID(StringRef Str)
Specifies the umbrella header used to create this module, if any.
Definition: ASTBitCodes.h:684
bool isVolatile() const
Definition: DeclCXX.h:1945
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:573
A namespace, stored as a NamespaceDecl*.
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:82
Record code for header search information.
Definition: ASTBitCodes.h:514
data_type ReadData(Selector, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:800
BlockCommandNamesTy BlockCommandNames
Command names to treat as block commands in comments.
void setProtocolRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:754
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:50
void setBegin(SourceLocation b)
std::string ModuleCachePath
The directory used for the module cache.
void setParameterList(ArrayRef< IdentifierInfo * > List, llvm::BumpPtrAllocator &PPAllocator)
Set the specified list of identifiers as the parameter list for this macro.
Definition: MacroInfo.h:158
Describes a source location entry (SLocEntry) for a buffer.
Definition: ASTBitCodes.h:622
Used to hold and unique data used to represent #line information.
Record code for the target options table.
Definition: ASTBitCodes.h:313
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:100
bool hasAttrOperand() const
Definition: TypeLoc.h:846
off_t getSize() const
Definition: FileManager.h:87
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
Definition: ASTReader.cpp:752
Record code for the array of eagerly deserialized decls.
Definition: ASTBitCodes.h:416
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
Definition: Module.h:88
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1434
Defines the clang::Expr interface and subclasses for C++ expressions.
unsigned isImport
True if this is a #import'd or #pragma once file.
Definition: HeaderSearch.h:41
Selector ReadSelector(ModuleFile &M, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.h:2034
int SLocEntryBaseID
The base ID in the source manager's view of this module.
Definition: Module.h:236
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
ContinuousRangeMap< uint32_t, int, 2 > DeclRemap
Remapping table for declaration IDs in this module.
Definition: Module.h:400
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1885
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap'ed memor...
The collection of all-type qualifiers we support.
Definition: Type.h:118
void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo)
Definition: TypeLoc.h:994
void clear()
Definition: ODRHash.cpp:163
SourceLocation ImportLoc
The source location where this module was first imported.
Definition: Module.h:194
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl * > &TentativeDefs) override
Read the set of tentative definitions known to the external Sema source.
Definition: ASTReader.cpp:7900
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:108
An UnresolvedSet-like class that might not have been loaded from the external AST source yet...
iterator begin(DeclarationName Name)
begin - Returns an iterator for decls with the name 'Name'.
The width of the "fast" qualifier mask.
Definition: Type.h:161
ModuleKind Kind
The kind of this module.
Definition: Module.h:75
The client can handle an AST file that cannot load because it is missing.
Definition: ASTReader.h:1447
CanQualType OCLSamplerTy
Definition: ASTContext.h:987
Defines the clang::SanitizerKind enum.
void ReadUndefinedButUsed(llvm::MapVector< NamedDecl *, SourceLocation > &Undefined) override
Load the set of used but not defined functions or variables with internal linkage, or used but not defined internal functions.
Definition: ASTReader.cpp:7875
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:40
void setIsGNUVarargs()
Definition: MacroInfo.h:198
StringRef ModuleOffsetMap
The module offset map data for this file.
Definition: Module.h:205
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3354
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
Definition: ASTBitCodes.h:39
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class...
SourceLocation getBegin() const
Definition: ASTBitCodes.h:178
static bool isWhitelistedDecl(const Decl *D, const CXXRecordDecl *Record)
Definition: ODRHash.cpp:349
DeclarationName getName() const
getName - Returns the embedded declaration name.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3249
bool isConst() const
Definition: DeclCXX.h:1944
One of these records is kept for each identifier that is lexed.
A macro directive exported by a module.
Definition: ASTBitCodes.h:659
void setLocalRangeEnd(SourceLocation L)
Definition: TypeLoc.h:1385
void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS)
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
Definition: ASTReader.cpp:145
void disableFileContentsOverride(const FileEntry *File)
Disable overridding the contents of a file, previously enabled with overrideFileContents.
Specifies a top-level header that falls into this (sub)module.
Definition: ASTBitCodes.h:688
std::string ActualOriginalSourceFileName
The actual original source file name that was used to build this AST file.
Definition: Module.h:134
The block containing comments.
Definition: ASTBitCodes.h:234
This table allows us to fully hide how we implement multi-keyword caching.
AddModuleResult
The result of attempting to add a new module.
StringLiteral * getMessage()
Definition: DeclCXX.h:3599
bool isDeclInLexicalTraversal(const Decl *D) const
Determine whether the given declaration is stored in the list of declarations lexically within this c...
Definition: DeclBase.h:1862
A library or framework to link against when an entity from this module is used.
Definition: Module.h:296
bool isNull() const
Definition: TypeLoc.h:102
void finalizeForWriting()
Finalizes the AST reader's state before writing an AST file to disk.
Definition: ASTReader.cpp:4487
Iteration over the preprocessed entities.
bool isFromAST() const
Return true if the identifier in its current state was loaded from an AST file.
static Module * getTopImportImplicitModule(ModuleManager &ModuleMgr, Preprocessor &PP)
Return the top import module if it is implicit, nullptr otherwise.
Definition: ASTReader.cpp:495
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:678
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
A C++ nested-name-specifier augmented with source location information.
Record the location of a macro definition.
LineState State
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:1840
The 'char' type, when it is signed.
Definition: ASTBitCodes.h:760
static std::string resolveFileRelativeToOriginalDir(const std::string &Filename, const std::string &OriginalDir, const std::string &CurrDir)
If a header file is not found at the path that we expect it to be and the PCH file was moved from its...
Definition: ASTReader.cpp:1276
serialization::SelectorID getGlobalSelectorID(ModuleFile &F, unsigned LocalID) const
Retrieve the global selector ID that corresponds to this the local selector ID in a given module...
Definition: ASTReader.cpp:8324
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:57
void setBuiltinLoc(SourceLocation Loc)
Definition: TypeLoc.h:534
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1602
Specifies a header that has been explicitly excluded from this submodule.
Definition: ASTBitCodes.h:701
void setRBracketLoc(SourceLocation Loc)
Definition: TypeLoc.h:1499
static SourceLocation getFromRawEncoding(unsigned Encoding)
Turn a raw encoding of a SourceLocation object into a real SourceLocation.
SmallVector< Requirement, 2 > Requirements
The set of language features required to use this module.
Definition: Module.h:182
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2366
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
llvm::MemoryBuffer * getRawBuffer() const
Get the underlying buffer, returning NULL if the buffer is not yet available.
The unsigned 128-bit integer type.
Definition: ASTBitCodes.h:997
ContinuousRangeMap< uint32_t, int, 2 > PreprocessedEntityRemap
Remapping table for preprocessed entity IDs in this module.
Definition: Module.h:322
Record code for the module map file that was used to build this AST file.
Definition: ASTBitCodes.h:295
One instance of this struct is kept for every file loaded or used.
Definition: SourceManager.h:99
std::vector< Entry > UserEntries
User specified include entries.
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1898
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:751
An ExtVectorType record.
Definition: ASTBitCodes.h:872
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
Delete expressions that will be analyzed later.
Definition: ASTBitCodes.h:588
std::vector< SystemHeaderPrefix > SystemHeaderPrefixes
User-specified system header prefixes.
llvm::SmallPtrSet< ModuleFile *, 4 > HitSet
A set of module files in which we found a result.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:281
Helper class that saves the current stream position and then restores it when destroyed.
Definition: ASTReader.h:2556
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
CanQualType OCLEventTy
Definition: ASTContext.h:987
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
Definition: Type.h:3150
unsigned getNumProtocols() const
Definition: TypeLoc.h:758
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1934
TemplateName ReadTemplateName(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a template name.
Definition: ASTReader.cpp:8441
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:725
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:397
The fast qualifier mask.
Definition: Type.h:164
virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the language options.
Definition: ASTReader.h:123
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:71
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
DeclarationName getCXXDestructorName(CanQualType Ty)
getCXXDestructorName - Returns the name of a C++ destructor for the given Type.
method_range methods() const
Definition: DeclObjC.h:982
void setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir, Twine NameAsWritten)
Sets the umbrella directory of the given module to the given directory.
Definition: ModuleMap.cpp:981
unsigned DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
QualType getTypeOfType(QualType t) const
getTypeOfType - Unlike many "get<Type>" functions, we don't unique TypeOfType nodes...
unsigned getNumProtocols() const
Definition: TypeLoc.h:1013
Wrapper for source info for unresolved typename using decls.
Definition: TypeLoc.h:660
std::string OriginalDir
The directory that the PCH was originally created in.
Definition: Module.h:142
void setKind(tok::TokenKind K)
Definition: Token.h:91
Sema * getSema()
Retrieve the semantic analysis object used to analyze the translation unit in which the precompiled h...
Definition: ASTReader.h:2223
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl * > &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
Definition: ASTReader.cpp:7932
An AttributedType record.
Definition: ASTBitCodes.h:918
An object-like macro definition.
Definition: ASTBitCodes.h:643
void setUnderlyingTInfo(TypeSourceInfo *TInfo)
Definition: TypeLoc.h:1818
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1457
CanQualType OCLReserveIDTy
Definition: ASTContext.h:988
The signature of a module, which is a hash of the AST content.
Definition: Module.h:47
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
SourceLocation getEnd() const
Definition: ASTBitCodes.h:181
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1295
Describes one token.
Definition: ASTBitCodes.h:652
internal_key_type ReadKey(const unsigned char *d, unsigned)
Definition: ASTReader.cpp:779
An AdjustedType record.
Definition: ASTBitCodes.h:930
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo > > &WI) override
Read the set of weak, undeclared identifiers known to the external Sema source.
Definition: ASTReader.cpp:7972
Describes a module or submodule.
Definition: Module.h:57
ASTReadResult ReadAST(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, unsigned ClientLoadCapabilities, SmallVectorImpl< ImportedSubmodule > *Imported=nullptr)
Load the AST file designated by the given file name.
Definition: ASTReader.cpp:3755
void completeVisibleDeclsMap(const DeclContext *DC) override
Load all external visible decls in the given DeclContext.
Definition: ASTReader.cpp:7302
unsigned LocalNumHeaderFileInfos
The number of local HeaderFileInfo structures.
Definition: Module.h:330
Record code for the set of ext_vector type names.
Definition: ASTBitCodes.h:460
iterator end()
end - Returns an iterator that has 'finished'.
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Definition: ASTReader.cpp:8843
llvm::Optional< ASTSourceDescriptor > getSourceDescriptor(unsigned ID) override
Return a descriptor for the corresponding module.
Definition: ASTReader.cpp:8261
static void collectMacroDefinitions(const PreprocessorOptions &PPOpts, MacroDefinitionsMap &Macros, SmallVectorImpl< StringRef > *MacroNames=nullptr)
Collect the macro definitions provided by the given preprocessor options.
Definition: ASTReader.cpp:544
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:169
const PPEntityOffset * PreprocessedEntityOffsets
Definition: Module.h:324
Specifies the submodules that are re-exported from this submodule.
Definition: ASTBitCodes.h:696
void setProtocolLoc(unsigned i, SourceLocation Loc)
Definition: TypeLoc.h:766
TemplateParameterList ** TemplParamLists
TemplParamLists - A new-allocated array of size NumTemplParamLists, containing pointers to the "outer...
Definition: Decl.h:617
std::string UserInfo
A string containing additional user information that will be stored with the metadata.
serialization::MacroID BaseMacroID
Base macro ID for macros local to this module.
Definition: Module.h:300
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:160
QualType getParenType(QualType NamedType) const
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:2152
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e...
Definition: Module.h:229
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:505
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:195
virtual void HandleInterestingDecl(DeclGroupRef D)
HandleInterestingDecl - Handle the specified interesting declaration.
Definition: ASTConsumer.cpp:23
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
PreprocessedEntity * ReadPreprocessedEntity(unsigned Index) override
Read a preallocated preprocessed entity from the external source.
Definition: ASTReader.cpp:5322
void setCaretLoc(SourceLocation Loc)
Definition: TypeLoc.h:1255
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2041
const LangOptions & getLangOpts() const
Definition: ASTContext.h:659
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:649
bool isAvailable() const
Determine whether this module is available for use within the current translation unit...
Definition: Module.h:352
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
TypeSourceInfo * GetTypeSourceInfo(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a declarator info from the given record.
Definition: ASTReader.cpp:6583
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:537
const unsigned NumSpecialTypeIDs
The number of special type IDs.
Definition: ASTBitCodes.h:966
A convenient class for passing around template argument information.
Definition: TemplateBase.h:524
void setcudaConfigureCallDecl(FunctionDecl *FD)
Definition: ASTContext.h:1185
uint32_t Offset
Definition: CacheTokens.cpp:43
Describes a blob that contains the data for a buffer entry.
Definition: ASTBitCodes.h:627
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Record code for the language options table.
Definition: ASTBitCodes.h:310
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1587
void ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8427
std::string Message
The message provided to the user when there is a conflict.
Definition: Module.h:338
Wrapper for source info for functions.
Definition: TypeLoc.h:1357
Specifies a conflict with another module.
Definition: ASTBitCodes.h:707
The signed 128-bit integer type.
Definition: ASTBitCodes.h:994
CXXCtorInitializer ** ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a CXXCtorInitializer array.
Definition: ASTReader.cpp:8613
llvm::APSInt ReadAPSInt(const RecordData &Record, unsigned &Idx)
Read a signed integral value.
Definition: ASTReader.cpp:8816
A UnaryTransformType record.
Definition: ASTBitCodes.h:924
An ObjCObjectType record.
Definition: ASTBitCodes.h:902
A ConstantArrayType record.
Definition: ASTBitCodes.h:864
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8836
void RemoveDecl(NamedDecl *D)
RemoveDecl - Unlink the decl from its shadowed decl chain.
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:697
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
llvm::iterator_range< ModuleDeclIterator > getModuleFileLevelDecls(ModuleFile &Mod)
Definition: ASTReader.cpp:5315
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:807
std::string getOwningModuleNameForDiagnostic(const Decl *D)
Get the best name we know for the module that owns the given declaration, or an empty string if the d...
Definition: ASTReader.cpp:8978
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, TemplateName replacement) const
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID)
Retrieve the global submodule ID given a module and its local ID number.
Definition: ASTReader.cpp:8197
Record code for #pragma optimize options.
Definition: ASTBitCodes.h:580
uint32_t BitOffset
Offset in the AST file.
Definition: ASTBitCodes.h:172
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8855
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1096
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:731
StringRef Data
The serialized bitstream data for this file.
Definition: Module.h:177
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
Specifies a header that is private to this submodule but must be textually included.
Definition: ASTBitCodes.h:715
Record code for pending implicit instantiations.
Definition: ASTBitCodes.h:490
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:800
ExtKind hasExternalDefinitions(const Decl *D) override
Definition: ASTReader.cpp:8278
CanQualType PseudoObjectTy
Definition: ASTContext.h:981
The internal '__make_integer_seq' template.
Definition: ASTBitCodes.h:1015
bool needsExtraLocalData() const
Definition: TypeLoc.h:556
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1734
void setLazyBody(uint64_t Offset)
Definition: DeclObjC.h:491
TemplateArgument ReadTemplateArgument(ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument.
Definition: ASTReader.cpp:8500
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTReader.h:2211
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
An ExtQualType record.
Definition: ASTBitCodes.h:850
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
Record code for floating point #pragma options.
Definition: ASTBitCodes.h:517
CommentRecordTypes
Record types used within a comments block.
Definition: ASTBitCodes.h:722
StringRef getName() const
Definition: FileManager.h:84
static internal_key_type ReadKey(const unsigned char *d, unsigned n)
Definition: ASTReader.cpp:847
CanQualType LongDoubleTy
Definition: ASTContext.h:974
void setMustBuildLookupTable()
Mark that there are external lexical declarations that we need to include in our lookup table (and th...
Definition: DeclBase.h:1825
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:346
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Module.h:197
std::string OriginalSourceFileName
The original source file name that was used to build the primary AST file, which may have been modifi...
Definition: Module.h:130
Wrapper for source info for ObjC interfaces.
Definition: TypeLoc.h:1083
Record code for the set of known namespaces, which are used for typo correction.
Definition: ASTBitCodes.h:527
static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps)
Definition: ASTReader.cpp:2185
Record code for an array of all of the (sub)modules that were imported by the AST file...
Definition: ASTBitCodes.h:548
serialization::DeclID BaseDeclID
Base declaration ID for declarations local to this module.
Definition: Module.h:397
Present this diagnostic as an error.
SourceLocation FirstLoc
The first source location in this module.
Definition: Module.h:197
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation > > &Pending) override
Read the set of pending instantiations known to the external Sema source.
Definition: ASTReader.cpp:8004
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:796
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
Definition: Diagnostic.h:412
A BlockPointerType record.
Definition: ASTBitCodes.h:856
void setProtocolLoc(unsigned i, SourceLocation Loc)
Definition: TypeLoc.h:1021
A MemberPointerType record.
Definition: ASTBitCodes.h:862
ContinuousRangeMap< uint32_t, int, 2 > SLocRemap
Remapping table for source locations in this module.
Definition: Module.h:249
unsigned DisableModuleHash
Whether we should disable the use of the hash string within the module cache.
void setLocalRangeBegin(SourceLocation L)
Definition: TypeLoc.h:1378
void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag)
Definition: ASTReader.cpp:5585
Represents an ObjC class declaration.
Definition: DeclObjC.h:1108
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclCXX.h:3606
The AST file itself appears corrupted.
Definition: ASTReader.h:347
detail::InMemoryDirectory::const_iterator I
void dump()
Dump information about the AST reader to standard error.
Definition: ASTReader.cpp:7478
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3227
unsigned getNumParams() const
Definition: TypeLoc.h:1426
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &Exprs) override
Definition: ASTReader.cpp:7885
static ASTFileSignature readASTFileSignature(StringRef PCH)
Reads and return the signature record from PCH's control block, or else returns 0.
Definition: ASTReader.cpp:4493
The preprocessor keeps track of this information for each file that is #included. ...
Definition: HeaderSearch.h:39
A DependentSizedExtVectorType record.
Definition: ASTBitCodes.h:938
uint64_t PreprocessorDetailStartOffset
The offset of the start of the preprocessor detail cursor.
Definition: Module.h:315
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C 'Class' type...
CanQualType UnsignedCharTy
Definition: ASTContext.h:972
Record code for the table of offsets into the block of source-location information.
Definition: ASTBitCodes.h:449
QualType getType() const
Definition: Decl.h:589
bool isInvalid() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:841
friend class ASTIdentifierIterator
Definition: ASTReader.h:366
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:1807
virtual bool needsInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
Definition: ASTReader.h:191
A SubstTemplateTypeParmPackType record.
Definition: ASTBitCodes.h:920
Objective-C "id" redefinition type.
Definition: ASTBitCodes.h:956
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl * > &Decls) override
Read the set of delegating constructors known to the external Sema source.
Definition: ASTReader.cpp:7921
static std::string ReadString(const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8829
TypeCode
Record codes for each kind of type.
Definition: ASTBitCodes.h:848
Records the location of a macro expansion.
DiagnosticsEngine & getDiagnostics() const
virtual void SelectorRead(serialization::SelectorID iD, Selector Sel)
A selector was read from the AST file.
virtual bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain)
Receives the file system options.
Definition: ASTReader.h:152
void setUnderlyingTInfo(TypeSourceInfo *TI) const
Definition: TypeLoc.h:1779
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
Definition: LangOptions.h:136
Class that aids in the construction of nested-name-specifiers along with source-location information ...
unsigned getObjCOrBuiltinID() const
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Module.h:207
The block containing information about the source manager.
Definition: ASTBitCodes.h:217
IdentifierInfo * GetIdentifierInfo(ModuleFile &M, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.h:1966
The placeholder type for OpenMP array section.
Definition: ASTBitCodes.h:826
A VariableArrayType record.
Definition: ASTBitCodes.h:868
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
void setLazyBody(uint64_t Offset)
Definition: Decl.h:1887
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:269
diag::Severity getExtensionHandlingBehavior() const
Definition: Diagnostic.h:601
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
Definition: ASTBitCodes.h:206
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
void setUsedForHeaderGuard(bool Val)
Definition: MacroInfo.h:267
ASTRecordTypes
Record types that occur within the AST block itself.
Definition: ASTBitCodes.h:354
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:953
static bool parseModuleFileExtensionMetadata(const SmallVectorImpl< uint64_t > &Record, StringRef Blob, ModuleFileExtensionMetadata &Metadata)
Parse a record and blob containing module file extension metadata.
Definition: ASTReader.cpp:4278
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement into a statement.
Definition: ASTReader.cpp:7143
unsigned NumTemplParamLists
NumTemplParamLists - The number of "outer" template parameter lists.
Definition: Decl.h:610
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3129
Defines the major attributes of a submodule, including its name and parent.
Definition: ASTBitCodes.h:681
llvm::BitstreamCursor Stream
The main bitstream cursor for the main block.
Definition: Module.h:180
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:130
llvm::DenseMap< ModuleFile *, serialization::DeclID > GlobalToLocalDeclIDs
Mapping from the module files that this module file depends on to the base declaration ID for that mo...
Definition: Module.h:409
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:636
ModuleHeaderRole
Flags describing the role of a module header.
Definition: ModuleMap.h:104
ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, unsigned PriorGeneration)
Definition: ASTReader.cpp:7753
ModuleKind
Specifies the kind of module that has been loaded.
Definition: Module.h:47
StringRef Filename
Definition: Format.cpp:1301
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:198
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:516
llvm::iterator_range< SmallVectorImpl< ModuleFile * >::const_iterator > pch_modules() const
A range covering the PCH and preamble module files loaded.
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2503
void SetGloballyVisibleDecls(IdentifierInfo *II, const SmallVectorImpl< uint32_t > &DeclIDs, SmallVectorImpl< Decl * > *Decls=nullptr)
Set the globally-visible declarations associated with the given identifier.
Definition: ASTReader.cpp:8070
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
Definition: DeclBase.h:693
ASTContext * Context
std::vector< bool > & Stack
void ReadModuleMapFile(StringRef ModuleMapPath) override
Definition: ASTReader.cpp:121
void setSizeExpr(Expr *Size)
Definition: TypeLoc.h:1510
unsigned LocalNumSLocEntries
The number of source location entries in this AST file.
Definition: Module.h:233
void setCFConstantStringType(QualType T)
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
Captures information about a #pragma weak directive.
Definition: Weak.h:25
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:2049
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
void visitInputFiles(serialization::ModuleFile &MF, bool IncludeSystem, bool Complain, llvm::function_ref< void(const serialization::InputFile &IF, bool isSystem)> Visitor)
Visit all the input files of the given module file.
Definition: ASTReader.cpp:8950
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2136
Record code for the table of offsets of each macro ID.
Definition: ASTBitCodes.h:565
const DirectoryEntry * Entry
Definition: Module.h:146
const uint32_t * TypeOffsets
Offset of each type within the bitstream, indexed by the type ID, or the representation of a Type*...
Definition: Module.h:433
void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo)
Definition: ASTReader.cpp:1899
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
unsigned UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2027
static NestedNameSpecifier * SuperSpecifier(const ASTContext &Context, CXXRecordDecl *RD)
Returns the nested name specifier representing the __super scope for the given CXXRecordDecl.
serialization::PreprocessedEntityID getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const
Determine the global preprocessed entity ID that corresponds to the given local ID within the given m...
Definition: ASTReader.cpp:1624
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, const TemplateArgumentListInfo &Args) const
A record containing CXXBaseSpecifiers.
Definition: ASTBitCodes.h:1189
ASTReaderListener implementation to validate the information of the PCH file against an initialized P...
Definition: ASTReader.h:264
int * Depth
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:139
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:1979
Specifies some declarations with initializers that must be emitted to initialize the module...
Definition: ASTBitCodes.h:718
An TemplateSpecializationType record.
Definition: ASTBitCodes.h:906
An ObjCObjectPointerType record.
Definition: ASTBitCodes.h:890
File is from a prebuilt module path.
Definition: Module.h:53
Type source information for an attributed type.
Definition: TypeLoc.h:827
An ObjCInterfaceType record.
Definition: ASTBitCodes.h:888
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
const Type * getTypePtrOrNull() const
Definition: Type.h:5493
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2001
HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE) override
Read the header file information for the given file entry.
Definition: ASTReader.cpp:5576
Describes a zlib-compressed blob that contains the data for a buffer entry.
Definition: ASTBitCodes.h:630
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:580
Expr - This represents one expression.
Definition: Expr.h:105
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
Definition: ASTReader.cpp:8243
Defines the clang::LangOptions interface.
StringRef getName() const
Return the actual identifier string.
Record code for the array of VTable uses.
Definition: ASTBitCodes.h:470
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
The 'char' type, when it is unsigned.
Definition: ASTBitCodes.h:748
void setHasCommaPasting()
Definition: MacroInfo.h:212
static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
Definition: ASTReader.cpp:853
static InputFile getNotFound()
Definition: Module.h:81
void setModeAttr(bool written)
Definition: TypeLoc.h:619
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTReader.cpp:8885
serialization::MacroID getGlobalMacroID(ModuleFile &M, unsigned LocalID)
Retrieve the global macro ID corresponding to the given local ID within the given module file...
Definition: ASTReader.cpp:8182
The directory that the PCH was originally created in.
Definition: ASTBitCodes.h:280
QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a type from the current position in the given record, which was read from the given AST file...
Definition: ASTReader.h:1725
Declaration of a template type parameter.
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name...
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
unsigned LocalNumIdentifiers
The number of identifiers in this AST file.
Definition: Module.h:254
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
Definition: ASTReader.cpp:7992
The placeholder type for overloaded function sets.
Definition: ASTBitCodes.h:780
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
Definition: LangOptions.h:150
Defines the clang::CommentOptions interface.
Implements an efficient mapping from strings to IdentifierInfo nodes.
Defines implementation details of the clang::SourceManager class.
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4503
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:54
virtual void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata)
Indicates that a particular module file extension has been read.
Definition: ASTReader.h:214
Expr * getBitWidth() const
Definition: Decl.h:2448
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
Inits[]
Definition: OpenMPClause.h:136
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
Definition: Module.h:236
Record code for the table of offsets to entries in the preprocessing record.
Definition: ASTBitCodes.h:467
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2551
ContinuousRangeMap< uint32_t, int, 2 > IdentifierRemap
Remapping table for identifier IDs in this module.
Definition: Module.h:267
CanQualType OMPArraySectionTy
Definition: ASTContext.h:989
llvm::BitstreamCursor SLocEntryCursor
Cursor used to read source location entries.
Definition: Module.h:230
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:111
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:956
Defines version macros and version-related utility functions for Clang.
The OpenCL 'half' / ARM NEON __fp16 type.
Definition: ASTBitCodes.h:808
const FileEntry * ContentsEntry
References the file which the contents were actually loaded from.
Defines an enumeration for C++ overloaded operators.
Defines the clang::Preprocessor interface.
ArgKind
The kind of template argument we're storing.
Definition: TemplateBase.h:43
serialization::DeclID getGlobalDeclID(ModuleFile &F, serialization::LocalDeclID LocalID) const
Map from a local declaration ID within a given module to a global declaration ID. ...
Definition: ASTReader.cpp:6957
The block containing the detailed preprocessing record.
Definition: ASTBitCodes.h:228
Kind getKind() const
Definition: DeclBase.h:410
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2088
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:213
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
Definition: ASTReader.h:293
Record code for #pragma diagnostic mappings.
Definition: ASTBitCodes.h:334
std::pair< SourceLocation, StringRef > getModuleImportLoc(int ID) override
Retrieve the module import location and module name for the given source manager entry ID...
Definition: ASTReader.cpp:1447
DeclContext * getDeclContext()
Definition: DeclBase.h:416
static LineEntry get(unsigned Offs, unsigned Line, int Filename, SrcMgr::CharacteristicKind FileKind, unsigned IncludeOffset)
void setWrittenSignSpec(TypeSpecifierSign written)
Definition: TypeLoc.h:585
llvm::BitstreamCursor InputFilesCursor
The cursor to the start of the input-files block.
Definition: Module.h:209
unsigned LocalNumMacros
The number of macros in this AST file.
Definition: Module.h:290
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a source range.
Definition: ASTReader.cpp:8799
A record containing CXXCtorInitializers.
Definition: ASTBitCodes.h:1191
CanQualType ShortTy
Definition: ASTContext.h:971
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl * > Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Record code for the original file that was used to generate the AST file, including both its file ID ...
Definition: ASTBitCodes.h:277
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:2159
Represents a C++ template name within the type system.
Definition: TemplateName.h:176
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used...
Definition: Module.h:313
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
Definition: Sanitizers.h:65
QualType getLocalType(ModuleFile &F, unsigned LocalID)
Resolve a local type ID within a given AST file into a type.
Definition: ASTReader.cpp:6769
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:100
A namespace alias, stored as a NamespaceAliasDecl*.
Record code for the diagnostic options table.
Definition: ASTBitCodes.h:331
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
Definition: ASTReader.cpp:174
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:973
An iterator that walks over all of the known identifiers in the lookup table.
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
Definition: Module.h:424
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1096
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1727
FileID OriginalSourceFileID
The file ID for the original source file that was used to build this AST file.
Definition: Module.h:138
A FunctionProtoType record.
Definition: ASTBitCodes.h:876
void setInheritConstructors(bool Inherit=true)
Set that this base class's constructors should be inherited.
Definition: DeclCXX.h:225
bool HasTimestamps
Whether timestamps are included in this module file.
Definition: Module.h:150
Describes a source location entry (SLocEntry) for a file.
Definition: ASTBitCodes.h:619
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
Wrapper for source info for enum types.
Definition: TypeLoc.h:698
A block containing a module file extension.
Definition: ASTBitCodes.h:255
bool isInstanceMethod() const
Definition: DeclObjC.h:416
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:116
std::string FileName
The file name of the module file.
Definition: Module.h:115
void setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader, Twine NameAsWritten)
Sets the umbrella header of the given module to the given header.
Definition: ModuleMap.cpp:969
void setEllipsisLoc(SourceLocation Loc)
Definition: TypeLoc.h:2106
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
Definition: DeclBase.h:707
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:681
Record code for an update to a decl context's lookup table.
Definition: ASTBitCodes.h:497
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
Definition: TypeLoc.h:720
void setHasBaseTypeAsWritten(bool HasBaseType)
Definition: TypeLoc.h:1040
Record the location of an inclusion directive, such as an #include or #import statement.
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
Definition: ASTReader.cpp:401
Record code for #pragma ms_struct options.
Definition: ASTBitCodes.h:591
InclusionKind
The kind of inclusion directives known to the preprocessor.
unsigned Map[FirstTargetAddressSpace]
The type of a lookup table which maps from language-specific address spaces to target-specific ones...
Definition: AddressSpaces.h:53
QualType withFastQualifiers(unsigned TQs) const
Definition: Type.h:825
unsigned ModulesValidateOncePerBuildSession
If true, skip verifying input files used by modules if the module was already verified during this bu...
struct CXXOpName CXXOperatorName
a DecltypeType record.
Definition: ASTBitCodes.h:892
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Trait class used to search the on-disk hash table containing all of the header search information...
QualType getSubstTemplateTypeParmPackType(const TemplateTypeParmType *Replaced, const TemplateArgument &ArgPack)
Retrieve a.
void insertOrReplace(const value_type &Val)
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
SourceLocation getFriendLoc() const
Retrieves the location of the 'friend' keyword.
Definition: DeclFriend.h:126
void deduplicateMergedDefinitonsFor(NamedDecl *ND)
Clean up the merged definition list.
Definition: ASTContext.cpp:900
void StartedDeserializing() override
Notify ASTReader that we started deserialization of a decl or type so until FinishedDeserializing is ...
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:183
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3624
Information about a header directive as found in the module map file.
Definition: Module.h:135
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
Definition: ASTContext.cpp:992
The result type of a method or function.
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1810
unsigned SLocEntryBaseOffset
The base offset in the source manager's view of this module.
Definition: Module.h:239
Record code for the table of offsets of each identifier ID.
Definition: ASTBitCodes.h:387
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:1943
SmallVector< uint64_t, 16 > PreloadedDeclIDs
Definition: ASTReader.h:2218
Record code for undefined but used functions and variables that need a definition in this TU...
Definition: ASTBitCodes.h:574
void ReadDeclarationNameInfo(ModuleFile &F, DeclarationNameInfo &NameInfo, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8417
A DependentNameType record.
Definition: ASTBitCodes.h:908
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true)
Lookup a module Search for a module with the given name.
const SourceManager & SM
Definition: Format.cpp:1293
unsigned MajorVersion
The major version of the extension data.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:232
CanQualType SignedCharTy
Definition: ASTContext.h:971
Record code for the identifier table.
Definition: ASTBitCodes.h:406
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:1893
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:419
The AST file was missing.
Definition: ASTReader.h:349
uint64_t BuildSessionTimestamp
The time in seconds when the build session started.
unsigned MinorVersion
The minor version of the extension data.
NestedNameSpecifier * ReadNestedNameSpecifier(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8679
void AddEntry(FileID FID, const std::vector< LineEntry > &Entries)
Add a new line entry that has already been encoded into the internal representation of the line table...
The placeholder type for bound member functions.
Definition: ASTBitCodes.h:802
void setIsUsed(bool Val)
Set the value of the IsUsed flag.
Definition: MacroInfo.h:146
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef)
Note that MergedDef is a redefinition of the canonical definition Def, so Def should be visible whene...
Definition: ASTReader.cpp:3664
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:541
unsigned readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID)
Reads a record with id AbbrevID from Cursor, resetting the internal state.
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1272
std::vector< std::unique_ptr< ModuleFileExtensionReader > > ExtensionReaders
The list of extension readers that are attached to this module file.
Definition: Module.h:201
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
Definition: ASTBitCodes.h:126
void setTypeofLoc(SourceLocation Loc)
Definition: TypeLoc.h:1720
SpecifierKind
The kind of specifier that completes this nested name specifier.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:400
std::pair< Module *, bool > findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, bool IsExplicit)
Find a new module or submodule, or create it if it does not already exist.
Definition: ModuleMap.cpp:730
void makeNamesVisible(const HiddenNames &Names, Module *Owner)
Make the names within this set of hidden names visible.
Definition: ASTReader.cpp:3601
StringRef Next() override
Retrieve the next string in the identifier table and advances the iterator for the following string...
Definition: ASTReader.cpp:7672
The 'unsigned long long' type.
Definition: ASTBitCodes.h:758
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:205
Wrapper for source info for arrays.
Definition: TypeLoc.h:1484
Record code for the set of source location entries that need to be preloaded by the AST reader...
Definition: ASTBitCodes.h:457
QualifierInfo - A struct with extended info about a syntactic name qualifier, to be used for the case...
Definition: Decl.h:603
CanQualType OverloadTy
Definition: ASTContext.h:979
The control block was read successfully.
Definition: ASTReader.h:345
The list of delegating constructor declarations.
Definition: ASTBitCodes.h:523
Information about a FileID, basically just the logical file that it represents and include stack info...
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:222
Compare comments' source locations.
Record code for types associated with OpenCL extensions.
Definition: ASTBitCodes.h:601
void setAttrOperandParensRange(SourceRange range)
Definition: TypeLoc.h:904
static bool readBit(unsigned &Bits)
Definition: ASTReader.cpp:863
void setIsFunctionLike()
Function/Object-likeness.
Definition: MacroInfo.h:192
const unsigned char * SelectorLookupTableData
A pointer to the character data that comprises the selector table.
Definition: Module.h:373
Encapsulates changes to the "macros namespace" (the location where the macro name became active...
Definition: MacroInfo.h:286
bool ReadFullVersionInformation(StringRef FullVersion) override
Receives the full Clang version information.
Definition: ASTReader.cpp:111
#define false
Definition: stdbool.h:33
serialization::TypeID BaseTypeIndex
Base type ID for types local to this module as represented in the global type ID space.
Definition: Module.h:437
CanQualType BuiltinFnTy
Definition: ASTContext.h:980
StringRef FileName
Definition: Format.cpp:1465
ContinuousRangeMap< uint32_t, int, 2 > SelectorRemap
Remapping table for selector IDs in this module.
Definition: Module.h:368
Kind
std::string ABI
If given, the name of the target ABI to use.
Definition: TargetOptions.h:42
void setASTFile(const FileEntry *File)
Set the serialized AST file for the top-level module of this module.
Definition: Module.h:429
bool isGlobalIndexUnavailable() const
Determine whether we tried to load the global index, but failed, e.g., because it is out-of-date or d...
Definition: ASTReader.cpp:3708
bool hasRevertedBuiltin() const
True if setNotBuiltin() was called.
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3220
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
Definition: ASTReader.cpp:8040
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2034
SmallVectorImpl< AnnotatedLine * >::const_iterator Next
serialization::IdentID BaseIdentifierID
Base identifier ID for identifiers local to this module.
Definition: Module.h:264
MacroInfo * ReadMacroRecord(ModuleFile &F, uint64_t Offset)
Reads the macro record located at the given offset.
Definition: ASTReader.cpp:1514
File is a PCH file treated as the preamble.
Definition: Module.h:51
ContinuousRangeMap< unsigned, int, 2 > SLocRemap
Definition: ASTUnit.cpp:2236
static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method)
Move the given method to the back of the global list of methods.
Definition: ASTReader.cpp:3573
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3255
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into '__super' nested-name-specifier.
ExternCContextDecl * getExternCContextDecl() const
Definition: ASTContext.cpp:974
Encodes a location in the source.
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
bool isOverridden() const
Definition: Module.h:88
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, StringRef ExistingModuleCachePath, DiagnosticsEngine *Diags, const LangOptions &LangOpts)
Check the header search options deserialized from the control block against the header search options...
Definition: ASTReader.cpp:726
const serialization::reader::DeclContextLookupTable * getLoadedLookupTables(DeclContext *Primary) const
Get the loaded lookup tables for Primary, if any.
Definition: ASTReader.cpp:7326
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5489
A record that stores the set of declarations that are visible from a given DeclContext.
Definition: ASTBitCodes.h:1118
File is a PCH file treated as such.
Definition: Module.h:50
CanQualType Int128Ty
Definition: ASTContext.h:971
IdentifierInfo * get(StringRef Name) override
Retrieve the IdentifierInfo for the named identifier.
Definition: ASTReader.cpp:7600
void setLength(unsigned Len)
Definition: Token.h:133
Specifies a library or framework to link against.
Definition: ASTBitCodes.h:703
Record code for file ID of the file or buffer that was used to generate the AST file.
Definition: ASTBitCodes.h:284
Represents a C++ temporary.
Definition: ExprCXX.h:1103
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5165
void InitializeContext()
Initializes the ASTContext.
Definition: ASTReader.cpp:4348
Specifies a header that falls into this (sub)module.
Definition: ASTBitCodes.h:686
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
ContinuousRangeMap< uint32_t, int, 2 > SubmoduleRemap
Remapping table for submodule IDs in this module.
Definition: Module.h:351
void setUsed(bool Used=true)
Definition: Weak.h:36
SourceRange getBraceRange() const
Definition: Decl.h:2935
A ComplexType record.
Definition: ASTBitCodes.h:852
Record code for special CUDA declarations.
Definition: ASTBitCodes.h:511
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
Options for controlling the compiler diagnostics engine.
A list of "interesting" identifiers.
Definition: ASTBitCodes.h:570
NameVisibilityKind NameVisibility
The visibility of names within this particular module.
Definition: Module.h:252
An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files...
Definition: ASTReader.cpp:7639
void setProtocolLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:745
The block of configuration options, used to check that a module is being used in a configuration comp...
Definition: ASTBitCodes.h:252
const std::string ID
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2816
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply...
void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl * > &Namespaces) override
Load the set of namespaces that are known to the external source, which will be used during typo corr...
Definition: ASTReader.cpp:7864
PredefinedTypeIDs
Predefined type IDs.
Definition: ASTBitCodes.h:740
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr * > VL, ArrayRef< Expr * > PL, ArrayRef< Expr * > IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
All of the names in this module are hidden.
Definition: Module.h:246
File is an implicitly-loaded module.
Definition: Module.h:48
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:733
void setProtocolRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1009
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
Metadata describing this particular extension.
Definition: ASTBitCodes.h:340
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:167
void setIsC99Varargs()
Varargs querying methods. This can only be set for function-like macros.
Definition: MacroInfo.h:197
MacroInfo * getMacro(serialization::MacroID ID)
Retrieve the macro with the given ID.
Definition: ASTReader.cpp:8156
uint64_t SizeInBits
The size of this file, in bits.
Definition: Module.h:171
TemplateParameterList * ReadTemplateParameterList(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a template parameter list.
Definition: ASTReader.cpp:8555
An ObjCTypeParamType record.
Definition: ASTBitCodes.h:934
void ProcessWarningOptions(DiagnosticsEngine &Diags, const DiagnosticOptions &Opts, bool ReportDiags=true)
ProcessWarningOptions - Initialize the diagnostic client and process the warning options specified on...
Definition: Warnings.cpp:44
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
bool isDeclIDFromModule(serialization::GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
Definition: ASTReader.cpp:6971
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1903
ModuleReverseIterator rbegin()
Reverse iterator to traverse all loaded modules.
Record code for the offsets of each decl.
Definition: ASTBitCodes.h:379
void setIdentifierInfo(IdentifierInfo *II)
Definition: Token.h:186
void ReadMethodPool(Selector Sel) override
Load the contents of the global method pool for a given selector.
Definition: ASTReader.cpp:7822
void * SelectorLookupTable
A pointer to an on-disk hash table of opaque type ASTSelectorLookupTable.
Definition: Module.h:380
Metadata for submodules as a whole.
Definition: ASTBitCodes.h:678
const uint32_t * IdentifierOffsets
Offsets into the identifier table data.
Definition: Module.h:261
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Class that performs lookup for a selector's entries in the global method pool stored in an AST file...
A TypeOfExprType record.
Definition: ASTBitCodes.h:880
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:90
Record code for late parsed template functions.
Definition: ASTBitCodes.h:577
CanQualType FloatTy
Definition: ASTContext.h:974
const FileEntry * Entry
Definition: Module.h:137
Defines the clang::TargetOptions class.
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier '::'.
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
void setDefinitionEndLoc(SourceLocation EndLoc)
Set the location of the last token in the macro.
Definition: MacroInfo.h:120
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:113
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
Definition: TargetOptions.h:55
unsigned LocalNumDecls
The number of declarations in this AST file.
Definition: Module.h:390
void setUpgradedFromWarning(bool Value)
The internal 'instancetype' typedef.
Definition: ASTBitCodes.h:1000
CanQualType VoidTy
Definition: ASTContext.h:963
OptionsRecordTypes
Record types that occur within the options block inside the control block.
Definition: ASTBitCodes.h:303
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:83
unsigned getNumTypeArgs() const
Definition: TypeLoc.h:985
Describes the categories of an Objective-C class.
Definition: ASTBitCodes.h:1608
uint32_t MacroID
An ID number that refers to a macro in an AST file.
Definition: ASTBitCodes.h:129
The AST block, which acts as a container around the full AST block.
Definition: ASTBitCodes.h:213
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition: Type.h:1258
IdentID ReadIdentifierID(const unsigned char *d)
Definition: ASTReader.cpp:869
A DeducedTemplateSpecializationType record.
Definition: ASTBitCodes.h:936
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1989
void setWrittenTypeSpec(TypeSpecifierType written)
Definition: TypeLoc.h:608
Objective-C "SEL" redefinition type.
Definition: ASTBitCodes.h:960
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line...
Definition: TargetOptions.h:51
SourceLocation getBegin() const
void setAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1330
UnhashedControlBlockRecordTypes
Record codes for the unhashed control block.
Definition: ASTBitCodes.h:326
llvm::SetVector< ModuleFile * > ImportedBy
List of modules which depend on this module.
Definition: Module.h:448
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1507
void setLBracketLoc(SourceLocation Loc)
Definition: TypeLoc.h:1492
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
void dump()
Dump debugging output for this module.
Definition: Module.cpp:43
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
static bool checkLanguageOptions(const LangOptions &LangOpts, const LangOptions &ExistingLangOpts, DiagnosticsEngine *Diags, bool AllowCompatibleDifferences=true)
Compare the given set of language options against an existing set of language options.
Definition: ASTReader.cpp:229
Updates[]
Definition: OpenMPClause.h:136
An InjectedClassNameType record.
Definition: ASTBitCodes.h:900
const serialization::DeclID * FileSortedDecls
Array of file-level DeclIDs sorted by file.
Definition: Module.h:412
Record code for the extra statistics we gather while generating an AST file.
Definition: ASTBitCodes.h:429
bool getEnableAllWarnings() const
Definition: Diagnostic.h:517
static Decl * getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID)
Definition: ASTReader.cpp:7008
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1898
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
virtual void visitImport(StringRef Filename)
If needsImportVisitation returns true, this is called for each AST file imported by this AST file...
Definition: ASTReader.h:211
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3576
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2140
static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool Complain)
Definition: ASTReader.cpp:419
std::vector< InputFile > InputFilesLoaded
The input files that have been loaded from this AST file.
Definition: Module.h:215
The module file was just loaded in response to this call.
DeclarationName ReadDeclarationName(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a declaration name.
Definition: ASTReader.cpp:8340
HashTableTy::const_iterator iterator
unsigned ComputeHash(Selector Sel)
Definition: ASTCommon.cpp:164
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:357
ArrayRef< ObjCMethodDecl * > getFactoryMethods() const
Retrieve the instance methods found by this visitor.
Definition: ASTReader.cpp:7799
bool wasUpgradedFromWarning() const
Whether this mapping attempted to map the diagnostic to a warning, but was overruled because the diag...
const char * HeaderFileInfoTableData
Actual data for the on-disk hash table of header file information.
Definition: Module.h:337
void markIdentifierUpToDate(IdentifierInfo *II)
Note that this identifier is up-to-date.
Definition: ASTReader.cpp:1888
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
const llvm::support::unaligned_uint64_t * InputFileOffsets
Offsets for all of the input file entries in the AST file.
Definition: Module.h:212
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:564
Record code for the signature that identifiers this AST file.
Definition: ASTBitCodes.h:328
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Definition: ModuleMap.cpp:1047
File is a PCH file treated as the actual main file.
Definition: Module.h:52
llvm::APFloat ReadAPFloat(const RecordData &Record, const llvm::fltSemantics &Sem, unsigned &Idx)
Read a floating-point value.
Definition: ASTReader.cpp:8822
Record code for referenced selector pool.
Definition: ASTBitCodes.h:475
The input file that has been loaded from this AST file, along with bools indicating whether this was ...
Definition: Module.h:59
void AddSubDecl(const Decl *D)
Definition: ODRHash.cpp:370
std::vector< std::string > MacroIncludes
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2308
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4437
ModuleFile * getLocalModuleFile(ModuleFile &M, unsigned ID)
Retrieve the module file with a given local ID within the specified ModuleFile.
Definition: ASTReader.cpp:8230
Record code for the set of non-builtin, special types.
Definition: ASTBitCodes.h:425
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
Defines various enumerations that describe declaration and type specifiers.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1392
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1581
void setTypeArgsLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:974
uint64_t InputFilesValidationTimestamp
If non-zero, specifies the time when we last validated input files.
Definition: Module.h:225
CanQualType UnsignedShortTy
Definition: ASTContext.h:972
const uint32_t * MacroOffsets
Offsets of macros in the preprocessor block.
Definition: Module.h:297
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2682
unsigned LocalNumSelectors
The number of selectors new to this file.
Definition: Module.h:358
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
CanQualType CharTy
Definition: ASTContext.h:965
unsigned NextIndex
Represents a template argument.
Definition: TemplateBase.h:40
Record code for the list of other AST files imported by this AST file.
Definition: ASTBitCodes.h:272
Selector getLocalSelector(ModuleFile &M, unsigned LocalID)
Retrieve a selector from the given module with its local ID number.
Definition: ASTReader.cpp:8285
Describes a macro definition within the preprocessing record.
Definition: ASTBitCodes.h:668
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:911
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
const ASTTemplateArgumentListInfo * ReadASTTemplateArgumentListInfo(ModuleFile &F, const RecordData &Record, unsigned &Index)
Definition: ASTReader.cpp:6842
A conflict between two modules.
Definition: Module.h:333
void setClassTInfo(TypeSourceInfo *TI)
Definition: TypeLoc.h:1282
bool ReadSLocEntry(int ID) override
Read the source location entry with index ID.
Definition: ASTReader.cpp:1304
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
Definition: ASTReader.cpp:743
The internal '__NSConstantString' typedef.
Definition: ASTBitCodes.h:1018
Record code for the module name.
Definition: ASTBitCodes.h:291
Selector getObjCSelector() const
getObjCSelector - Get the Objective-C selector stored in this declaration name.
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, const TemplateArgument &ArgPack) const
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:982
void ResolveImportedPath(ModuleFile &M, std::string &Filename)
If we are loading a relocatable PCH or module file, and the filename is not an absolute path...
Definition: ASTReader.cpp:2170
uint64_t SanitizerMask
Definition: Sanitizers.h:24
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
Definition: ASTReader.cpp:760
Describes an inclusion directive within the preprocessing record.
Definition: ASTBitCodes.h:672
The internal '__builtin_ms_va_list' typedef.
Definition: ASTBitCodes.h:1009
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block.
Definition: Module.h:387
unsigned IsMissingRequirement
Whether this module is missing a feature from Requirements.
Definition: Module.h:185
not evaluated yet, for special member function
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1215
Record code for a file sorted array of DeclIDs in a module.
Definition: ASTBitCodes.h:544
void setAmpAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1343
CanQualType NullPtrTy
Definition: ASTContext.h:978
Record code for the array of Objective-C categories (including extensions).
Definition: ASTBitCodes.h:558
void updateOutOfDateIdentifier(IdentifierInfo &II) override
Update an out-of-date identifier.
Definition: ASTReader.cpp:1863
void reserve(ASTContext &C, unsigned N)
Specifies a configuration macro for this module.
Definition: ASTBitCodes.h:705
void ReadDefinedMacros() override
Read the set of macros defined by this external macro source.
Definition: ASTReader.cpp:1756
StringRef Name
Definition: USRFinder.cpp:123
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:378
PreprocessorDetailRecordTypes
Record types used within a preprocessor detail block.
Definition: ASTBitCodes.h:663
static std::pair< GlobalModuleIndex *, ErrorCode > readIndex(StringRef Path)
Read a global index file for the given directory.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
static unsigned moduleKindForDiagnostic(ModuleKind Kind)
Definition: ASTReader.cpp:4001
bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain) override
Receives the file system options.
Definition: ASTReader.cpp:152
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
uint64_t MacroStartOffset
The offset of the start of the set of defined macros.
Definition: Module.h:306
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:63
Record code for the array of unused file scoped decls.
Definition: ASTBitCodes.h:463
A FunctionNoProtoType record.
Definition: ASTBitCodes.h:874
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
Definition: LangOptions.h:146
static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID)
Given a cursor at the start of an AST file, scan ahead and drop the cursor into the start of the give...
Definition: ASTReader.cpp:3728
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:328
File is an explicitly-loaded module.
Definition: Module.h:49
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2594
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
Definition: ASTReader.cpp:392
ModuleFile & getPrimaryModule()
Returns the primary module associated with the manager, that is, the first module loaded...
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:973
bool visitInputFile(StringRef Filename, bool isSystem, bool isOverridden, bool isExplicitModule) override
if needsInputFileVisitation returns true, this is called for each non-system input file of the AST Fi...
Definition: ASTReader.cpp:193
QualType getEnumType(const EnumDecl *Decl) const
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
bool isErrorOrFatal() const
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:537
Record code for the Objective-C method pool,.
Definition: ASTBitCodes.h:441
virtual void ReadModuleMapFile(StringRef ModuleMapPath)
Definition: ASTReader.h:118
Specifies a header that is private to this submodule.
Definition: ASTBitCodes.h:709
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool needsInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
Definition: ASTReader.cpp:179
U cast(CodeGen::Address addr)
Definition: Address.h:109
Describes a macro expansion within the preprocessing record.
Definition: ASTBitCodes.h:665
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
StringRef getString() const
Definition: Expr.h:1554
size_t param_size() const
Definition: Decl.h:2081
Selector getSelector() const
Definition: DeclObjC.h:328
void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl * > &Decls) override
Read all of the declarations lexically stored in a declaration context.
Definition: ASTReader.cpp:7156
An EnumType record.
Definition: ASTBitCodes.h:886
detail::InMemoryDirectory::const_iterator E
IdentifierTable & getIdentifierTable()
Retrieve the identifier table associated with the preprocessor.
Definition: ASTReader.cpp:8872
IdentifierResolver IdResolver
Definition: Sema.h:779
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2087
A map from continuous integer ranges to some value, with a very specialized interface.
Class that performs lookup for an identifier stored in an AST file.
void setExternalSLocEntrySource(ExternalSLocEntrySource *Source)
ContinuousRangeMap< uint32_t, int, 2 > MacroRemap
Remapping table for macro IDs in this module.
Definition: Module.h:303
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
An RValueReferenceType record.
Definition: ASTBitCodes.h:860
void ReadDeclarationNameLoc(ModuleFile &F, DeclarationNameLoc &DNLoc, DeclarationName Name, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8384
A type that was preceded by the 'template' keyword, stored as a Type*.
void ClearSwitchCaseIDs()
Definition: ASTReader.cpp:8890
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, uint32_t Raw) const
Read a source location from raw form.
Definition: ASTReader.h:2105
std::string BlockName
The name used to identify this particular extension block within the resulting module file...
SourceMgr(SourceMgr)
void setHasExternalLexicalStorage(bool ES=true)
State whether this DeclContext has external storage for declarations lexically in this context...
Definition: DeclBase.h:1844
unsigned getTotalNumSelectors() const
Returns the number of selectors found in the chain.
Definition: ASTReader.h:1681
void ReadLateParsedTemplates(llvm::MapVector< const FunctionDecl *, std::unique_ptr< LateParsedTemplate >> &LPTMap) override
Read the set of late parsed template functions for this source.
Definition: ASTReader.cpp:8016
An AtomicType record.
Definition: ASTBitCodes.h:926
BuiltinTemplateDecl * getTypePackElementDecl() const
static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, ASTConsumer *Consumer)
Under non-PCH compilation the consumer receives the objc methods before receiving the implementation...
Definition: ASTReader.cpp:7335
The placeholder type for dependent types.
Definition: ASTBitCodes.h:782
const TemplateArgument & getArg(unsigned Idx) const
Definition: TemplateBase.h:666
All of the names in this module are visible.
Definition: Module.h:248
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1953
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
Number of unmatched #pragma clang cuda_force_host_device begin directives we've seen.
Definition: ASTBitCodes.h:598
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:34
Decl * GetExternalDecl(uint32_t ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: ASTReader.cpp:6854
std::string toString(const til::SExpr *E)
IdentifierResolver & getIdResolver()
Get the identifier resolver used for name lookup / updates in the translation unit scope...
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:839
uint32_t getGeneration() const
Get the current generation of this AST source.
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition: Type.h:3230
time_t getModificationTime() const
Definition: FileManager.h:91
void ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set, const RecordData &Record, unsigned &Idx)
Read a UnresolvedSet structure.
Definition: ASTReader.cpp:8585
QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl, ArrayRef< ObjCProtocolDecl * > protocols, QualType Canonical=QualType()) const
void setAttrEnumOperandLoc(SourceLocation loc)
Definition: TypeLoc.h:891
struct CXXLitOpName CXXLiteralOperatorName
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:105
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3784
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:428
CanQualType UnknownAnyTy
Definition: ASTContext.h:979
std::vector< Conflict > Conflicts
The list of conflicts.
Definition: Module.h:342
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:6042
NestedNameSpecifierLoc ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8735
std::pair< unsigned, unsigned > findPreprocessedEntitiesInRange(SourceRange Range) override
Returns a pair of [Begin, End) indices of preallocated preprocessed entities that Range encompasses...
Definition: ASTReader.cpp:5511
Record code for the table of offsets into the Objective-C method pool.
Definition: ASTBitCodes.h:438
NamedDecl * getFriendDecl() const
If this friend declaration doesn't name a type, return the inner declaration.
Definition: DeclFriend.h:121
Defines the clang::FileSystemOptions interface.
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2105
A DependentSizedArrayType record.
Definition: ASTBitCodes.h:912
CanQualType UnsignedLongTy
Definition: ASTContext.h:972
Record code for the remapping information used to relate loaded modules to the various offsets and ID...
Definition: ASTBitCodes.h:533
bool isInvalid() const
virtual bool needsImportVisitation() const
Returns true if this ASTReaderListener wants to receive the imports of the AST file via visitImport...
Definition: ASTReader.h:208
A key used when looking up entities by DeclarationName.
Definition: ASTBitCodes.h:1638
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1281
void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata) override
Indicates that a particular module file extension has been read.
Definition: ASTReader.cpp:209
Record code for declarations that Sema keeps references of.
Definition: ASTBitCodes.h:484
void ReadTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument array.
Definition: ASTReader.cpp:8575
CanQualType DependentTy
Definition: ASTContext.h:979
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1857
void * HeaderFileInfoTable
The on-disk hash table that contains information about each of the header files.
Definition: Module.h:341
CanQualType WCharTy
Definition: ASTContext.h:966
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
Definition: ASTBitCodes.h:139
void visitTopLevelModuleMaps(serialization::ModuleFile &MF, llvm::function_ref< void(const FileEntry *)> Visitor)
Visit all the top-level module maps loaded when building the given module file.
Definition: ASTReader.cpp:8965
bool hasBody() const override
Determine whether this method has a body.
Definition: DeclObjC.h:486
Offsets into the input-files block where input files reside.
Definition: ASTBitCodes.h:288
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
Definition: ASTReader.cpp:127
CanQualType ObjCBuiltinClassTy
Definition: ASTContext.h:982
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:771
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1634
PreprocessorRecordTypes
Record types used within a preprocessor block.
Definition: ASTBitCodes.h:637
static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags)
Definition: ASTReader.cpp:449
CanQualType BoundMemberTy
Definition: ASTContext.h:979
The block containing the submodule structure.
Definition: ASTBitCodes.h:231
void setTypeArgsRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:981
Wrapper for source info for record types.
Definition: TypeLoc.h:690
std::string BaseDirectory
The base directory of the module.
Definition: Module.h:121
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1832
unsigned CalculateHash()
Definition: ODRHash.cpp:170
bool isOutOfDate() const
Definition: Module.h:89
The template argument is a type.
Definition: TemplateBase.h:48
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
PragmaMSStructKind
Definition: PragmaKinds.h:24
Wraps an ObjCPointerType with source location information.
Definition: TypeLoc.h:1300
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:386
ContinuousRangeMap< uint32_t, int, 2 > TypeRemap
Remapping table for type IDs in this module.
Definition: Module.h:440
Selector DecodeSelector(serialization::SelectorID Idx)
Definition: ASTReader.cpp:8289
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
bool isInvalid() const
The template argument is actually a parameter pack.
Definition: TemplateBase.h:72
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
Definition: Module.h:319
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
Definition: TemplateBase.h:660
Represents a base class of a C++ class.
Definition: DeclCXX.h:158
Cached information about one directory (either on disk or in the virtual file system).
Definition: FileManager.h:45
uint32_t GetNumExternalSelectors() override
Returns the number of selectors known to the external AST source.
Definition: ASTReader.cpp:8318
unsigned BufferOverridden
Indicates whether the buffer itself was provided to override the actual file contents.
const Expr * Replacement
Definition: AttributeList.h:59
void PrintStats() override
Print some statistics about AST usage.
Definition: ASTReader.cpp:7362
void setSeverity(diag::Severity Value)
Defines the clang::TokenKind enum and support functions.
void insert(const value_type &Val)
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
Metadata for a module file extension.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3222
Keeps track of options that affect how file operations are performed.
A TypedefType record.
Definition: ASTBitCodes.h:878
static bool ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID)
ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the specified cursor.
Definition: ASTReader.cpp:1484
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
Definition: ASTReader.cpp:6596
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
IdentifierInfo * DecodeIdentifierInfo(serialization::IdentifierID ID)
Definition: ASTReader.cpp:8102
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3224
NestedNameSpecifierLoc QualifierLoc
Definition: Decl.h:604
virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain)
Receives the header search options.
Definition: ASTReader.h:161
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Canon=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
QualType getTypeOfExprType(Expr *e) const
GCC extension.
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
getCXXLiteralOperatorName - Get the name of the literal operator function with II as the identifier...
bool hasRevertedTokenIDToIdentifier() const
True if revertTokenIDToIdentifier() was called.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:2145
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
Definition: ASTBitCodes.h:157
void FindFileRegionDecls(FileID File, unsigned Offset, unsigned Length, SmallVectorImpl< Decl * > &Decls) override
Get the decls that are contained in a file in the Offset/Length range.
Definition: ASTReader.cpp:7232
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type...
FormatToken * Current
TemplateArgumentLoc ReadTemplateArgumentLoc(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a TemplateArgumentLoc.
Definition: ASTReader.cpp:6829
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
Definition: Module.h:221
void setEnd(SourceLocation e)
TemplateArgumentLocInfo GetTemplateArgumentLocInfo(ModuleFile &F, TemplateArgument::ArgKind Kind, const RecordData &Record, unsigned &Idx)
Reads a TemplateArgumentLocInfo appropriate for the given TemplateArgument kind.
Definition: ASTReader.cpp:6793
Represents a C++ struct/union/class.
Definition: DeclCXX.h:267
BoundNodesTreeBuilder *const Builder
Selector GetExternalSelector(serialization::SelectorID ID) override
Resolve a selector ID into a selector.
Definition: ASTReader.cpp:8314
static const ASTTemplateArgumentListInfo * Create(ASTContext &C, const TemplateArgumentListInfo &List)
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
Definition: ASTBitCodes.h:142
serialization::DeclID ReadDeclID(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a declaration ID from the given position in a record in the given module.
Definition: ASTReader.cpp:7127
virtual bool needsSystemInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
Definition: ASTReader.h:194
An TemplateTypeParmType record.
Definition: ASTBitCodes.h:904
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
Definition: Module.h:265
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:60
bool needsSystemInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
Definition: ASTReader.cpp:183
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Definition: ExprCXX.cpp:720
SmallVector< uint64_t, 8 > PragmaDiagMappings
Diagnostic IDs and their mappings that the user changed.
Definition: Module.h:445
Record code for the filesystem options table.
Definition: ASTBitCodes.h:316
static hash_value_type ComputeHash(const internal_key_type &a)
Definition: ASTReader.cpp:834
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
Definition: ASTReader.cpp:1501
const char * IdentifierTableData
Actual data for the on-disk hash table of identifiers.
Definition: Module.h:273
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1432
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
Definition: ASTCommon.cpp:326
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:623
const FileEntry * getFile() const
Definition: Module.h:87
CanQualType Char16Ty
Definition: ASTContext.h:969
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:150
static DiagnosticMapping deserialize(unsigned Bits)
Deserialize a mapping.
void setOutOfDate(bool OOD)
Set whether the information for this identifier is out of date with respect to the external source...
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1133
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
Definition: Module.h:394
Location information for a TemplateArgument.
Definition: TemplateBase.h:369
virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the target options.
Definition: ASTReader.h:133
Record code for the offsets of each type.
Definition: ASTBitCodes.h:367
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:2668
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
The block containing the definitions of all of the types and decls used within the AST file...
Definition: ASTBitCodes.h:225
The internal '__va_list_tag' struct, if any.
Definition: ASTBitCodes.h:1006
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1299
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:44
virtual void ReadModuleName(StringRef ModuleName)
Definition: ASTReader.h:117
TypedefDecl * getCFConstantStringDecl() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:245
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
Definition: ASTReader.cpp:518
ASTIdentifierIterator(const ASTReader &Reader, bool SkipModules=false)
Definition: ASTReader.cpp:7667
The module file had already been loaded.
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1506
Defines the clang::TargetInfo interface.
The AST file is out-of-date relative to its input files, and needs to be regenerated.
Definition: ASTReader.h:352
TypeLocReader(ModuleFile &F, ASTReader &Reader, const ASTReader::RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:6297
Defines the clang::VersionTuple class, which represents a version in the form major[.minor[.subminor]].
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:244
void setPrevious(MacroDirective *Prev)
Set previous definition of the macro with the same name.
Definition: MacroInfo.h:318
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1813
a linked list of methods with the same selector name but different signatures.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3471
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1595
std::pair< ObjCMethodList, ObjCMethodList > GlobalMethods
Definition: Sema.h:1087
data_type ReadData(const internal_key_type &k, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:884
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:84
Specifies a required feature.
Definition: ASTBitCodes.h:698
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
SourceLocation getSourceLocationForDeclID(serialization::GlobalDeclID ID)
Returns the source location for the decl ID.
Definition: ASTReader.cpp:6989
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:317
TagDecl * getDecl() const
Definition: Type.cpp:2986
void AddStmt(const Stmt *S)
Definition: ODRHash.cpp:25
SourceRange getSourceRange() const override LLVM_READONLY
Retrieves the source range for the friend declaration.
Definition: DeclFriend.h:131
CanQualType IntTy
Definition: ASTContext.h:971
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
The AST file was written by a different version of Clang.
Definition: ASTReader.h:354
Record for offsets of DECL_UPDATES records for declarations that were modified after being deserializ...
Definition: ASTBitCodes.h:501
unsigned ModuleMapFileHomeIsCwd
Set the 'home directory' of a module map file to the current working directory (or the home directory...
static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool IsSystem, bool Complain)
Definition: ASTReader.cpp:456
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions)
Read the control block for the named AST file.
Definition: ASTReader.cpp:4618
llvm::BitstreamCursor PreprocessorDetailCursor
The cursor to the start of the (optional) detailed preprocessing record block.
Definition: Module.h:312
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
void setProtocolLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1002
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1090
void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, SourceLocation ColonColonLoc)
Extend the current nested-name-specifier by another nested-name-specifier component of the form 'type...
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
ModuleFile * getOwningModuleFile(const Decl *D)
Retrieve the module file that owns the given declaration, or NULL if the declaration is not from a mo...
Definition: ASTReader.cpp:6981
RecordDecl * getCFConstantStringTagDecl() const
Record code for weak undeclared identifiers.
Definition: ASTBitCodes.h:487
The block containing information about the preprocessor.
Definition: ASTBitCodes.h:221
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined 'SEL' type in Objective-C.
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type...
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:709
void StartTranslationUnit(ASTConsumer *Consumer) override
Function that will be invoked when we begin parsing a new translation unit involving this external AS...
Definition: ASTReader.cpp:7352
A DecayedType record.
Definition: ASTBitCodes.h:928
void setLocation(SourceLocation L)
Definition: Token.h:132
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:80
unsigned getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
Definition: DeclBase.h:685
Wrapper for source info for builtin types.
Definition: TypeLoc.h:526
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1136
A set of overloaded template declarations.
Definition: TemplateName.h:192
Wrapper for template type parameters.
Definition: TypeLoc.h:706
Record code for the headers search options table.
Definition: ASTBitCodes.h:319
Module * Other
The module that this module conflicts with.
Definition: Module.h:335
A trivial tuple used to represent a source range.
SourceLocation getLocation() const
Definition: DeclBase.h:407
NamedDecl - This represents a decl with a name.
Definition: Decl.h:213
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
Definition: ASTContext.h:1636
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
Definition: ASTContext.h:1614
AST file metadata, including the AST file version number and information about the compiler used to b...
Definition: ASTBitCodes.h:268
bool isFileOverridden(const FileEntry *File) const
Returns true if the file contents have been overridden.
The block of input files, which were used as inputs to create this AST file.
Definition: ASTBitCodes.h:245
static DeclarationName getUsingDirectiveName()
getUsingDirectiveName - Return name for all using-directives.
Present this diagnostic as a warning.
ObjCMethodList * getNext() const
llvm::BitstreamCursor MacroCursor
The cursor to the start of the preprocessor block, which stores all of the macro definitions.
Definition: Module.h:287
const uint32_t * SelectorOffsets
Offsets into the selector lookup table's data array where each selector resides.
Definition: Module.h:362
CanQualType BoolTy
Definition: ASTContext.h:964
void UpdateSema()
Update the state of Sema after loading some additional modules.
Definition: ASTReader.cpp:7539
unsigned LocalNumTypes
The number of types in this AST file.
Definition: Module.h:429
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:747
Represents a C++ namespace alias.
Definition: DeclCXX.h:2861
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1616
Kind
The basic Objective-C runtimes that we know about.
Definition: ObjCRuntime.h:28
bool isValid() const
The internal '__NSConstantString' tag type.
Definition: ASTBitCodes.h:1021
static TypeIdx fromTypeID(TypeID ID)
Definition: ASTBitCodes.h:96
serialization::DeclID mapGlobalIDToModuleFileGlobalID(ModuleFile &M, serialization::DeclID GlobalID)
Map a global declaration ID into the declaration ID used to refer to this declaration within the give...
Definition: ASTReader.cpp:7110
InputFileRecordTypes
Record types that occur within the input-files block inside the control block.
Definition: ASTBitCodes.h:348
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl * > &Decls) override
Read the set of unused file-scope declarations known to the external Sema source. ...
Definition: ASTReader.cpp:7910
void FinishedDeserializing() override
Notify ASTReader that we finished the deserialization of a decl or type.
CanQualType DoubleTy
Definition: ASTContext.h:974
A function-like macro definition.
Definition: ASTBitCodes.h:648
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:683
~ASTReader() override
The Objective-C 'Protocol' type.
Definition: ASTBitCodes.h:991
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
The global specifier '::'. There is no stored value.
DiagnosticBuilder Diag(unsigned DiagID) const
Report a diagnostic.
Definition: ASTReader.cpp:8862
T * getFETokenInfo() const
getFETokenInfo/setFETokenInfo - The language front-end is allowed to associate arbitrary metadata wit...
The control block, which contains all of the information that needs to be validated prior to committi...
Definition: ASTBitCodes.h:239
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:257
Wrapper for source info for pointers.
Definition: TypeLoc.h:1236
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1249
void ReadModuleName(StringRef ModuleName) override
Definition: ASTReader.cpp:116
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
Definition: SourceManager.h:87
This class handles loading and caching of source files into memory.
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3254
PredefinedDeclIDs
Predefined declaration IDs.
Definition: ASTBitCodes.h:974
Record code for an update to the TU's lexically contained declarations.
Definition: ASTBitCodes.h:479
A class which abstracts out some details necessary for making a call.
Definition: Type.h:2948
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1876
Source range/offset of a preprocessed entity.
Definition: ASTBitCodes.h:187
const NamedDecl * Result
Definition: USRFinder.cpp:70
void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind) override
This is called for each AST file loaded.
Definition: ASTReader.cpp:187
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID...
Definition: Module.h:417
bool loadGlobalIndex()
Attempts to load the global index.
Definition: ASTReader.cpp:3686
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: ASTReader.cpp:8226
Objective-C "Class" redefinition type.
Definition: ASTBitCodes.h:958
A PackExpansionType record.
Definition: ASTBitCodes.h:916
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
Definition: ASTReader.cpp:7942
A single template declaration.
Definition: TemplateName.h:190
CanQualType OCLClkEventTy
Definition: ASTContext.h:987
The pseudo-object placeholder type.
Definition: ASTBitCodes.h:812
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
Definition: ASTBitCodes.h:163
virtual bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain)
Receives the diagnostic options.
Definition: ASTReader.h:143
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Definition: Module.h:225
Record code for #pragma ms_struct options.
Definition: ASTBitCodes.h:594
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
Definition: ASTReader.cpp:8878
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:98
A DependentTemplateSpecializationType record.
Definition: ASTBitCodes.h:910
CanQualType UnsignedIntTy
Definition: ASTContext.h:972
bool ParseAllComments
Treat ordinary comments as documentation comments.
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2431
serialization::IdentifierID getGlobalIdentifierID(ModuleFile &M, unsigned LocalID)
Definition: ASTReader.cpp:8141
Record code for the array of tentative definitions.
Definition: ASTBitCodes.h:432
static void addMethodsToPool(Sema &S, ArrayRef< ObjCMethodDecl * > Methods, ObjCMethodList &List)
Add the given set of methods to the method list.
Definition: ASTReader.cpp:7815
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
Definition: DeclBase.h:1850
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++1z deduced class template specialization type.
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.