clang  7.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/DeclBase.h"
23 #include "clang/AST/DeclCXX.h"
24 #include "clang/AST/DeclFriend.h"
25 #include "clang/AST/DeclGroup.h"
26 #include "clang/AST/DeclObjC.h"
27 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/Expr.h"
30 #include "clang/AST/ExprCXX.h"
33 #include "clang/AST/ODRHash.h"
35 #include "clang/AST/TemplateBase.h"
36 #include "clang/AST/TemplateName.h"
37 #include "clang/AST/Type.h"
38 #include "clang/AST/TypeLoc.h"
42 #include "clang/Basic/Diagnostic.h"
48 #include "clang/Basic/LLVM.h"
51 #include "clang/Basic/Module.h"
55 #include "clang/Basic/Sanitizers.h"
59 #include "clang/Basic/Specifiers.h"
60 #include "clang/Basic/TargetInfo.h"
62 #include "clang/Basic/TokenKinds.h"
63 #include "clang/Basic/Version.h"
65 #include "clang/Lex/HeaderSearch.h"
67 #include "clang/Lex/MacroInfo.h"
68 #include "clang/Lex/ModuleMap.h"
70 #include "clang/Lex/Preprocessor.h"
72 #include "clang/Lex/Token.h"
74 #include "clang/Sema/Scope.h"
75 #include "clang/Sema/Sema.h"
76 #include "clang/Sema/Weak.h"
85 #include "llvm/ADT/APFloat.h"
86 #include "llvm/ADT/APInt.h"
87 #include "llvm/ADT/APSInt.h"
88 #include "llvm/ADT/ArrayRef.h"
89 #include "llvm/ADT/DenseMap.h"
90 #include "llvm/ADT/FoldingSet.h"
91 #include "llvm/ADT/Hashing.h"
92 #include "llvm/ADT/IntrusiveRefCntPtr.h"
93 #include "llvm/ADT/None.h"
94 #include "llvm/ADT/Optional.h"
95 #include "llvm/ADT/STLExtras.h"
96 #include "llvm/ADT/SmallPtrSet.h"
97 #include "llvm/ADT/SmallString.h"
98 #include "llvm/ADT/SmallVector.h"
99 #include "llvm/ADT/StringExtras.h"
100 #include "llvm/ADT/StringMap.h"
101 #include "llvm/ADT/StringRef.h"
102 #include "llvm/ADT/Triple.h"
103 #include "llvm/ADT/iterator_range.h"
104 #include "llvm/Bitcode/BitstreamReader.h"
105 #include "llvm/Support/Casting.h"
106 #include "llvm/Support/Compiler.h"
107 #include "llvm/Support/Compression.h"
108 #include "llvm/Support/DJB.h"
109 #include "llvm/Support/Endian.h"
110 #include "llvm/Support/Error.h"
111 #include "llvm/Support/ErrorHandling.h"
112 #include "llvm/Support/FileSystem.h"
113 #include "llvm/Support/MemoryBuffer.h"
114 #include "llvm/Support/Path.h"
115 #include "llvm/Support/SaveAndRestore.h"
116 #include "llvm/Support/Timer.h"
117 #include "llvm/Support/VersionTuple.h"
118 #include "llvm/Support/raw_ostream.h"
119 #include <algorithm>
120 #include <cassert>
121 #include <cstddef>
122 #include <cstdint>
123 #include <cstdio>
124 #include <ctime>
125 #include <iterator>
126 #include <limits>
127 #include <map>
128 #include <memory>
129 #include <string>
130 #include <system_error>
131 #include <tuple>
132 #include <utility>
133 #include <vector>
134 
135 using namespace clang;
136 using namespace clang::serialization;
137 using namespace clang::serialization::reader;
138 using llvm::BitstreamCursor;
139 
140 //===----------------------------------------------------------------------===//
141 // ChainedASTReaderListener implementation
142 //===----------------------------------------------------------------------===//
143 
144 bool
146  return First->ReadFullVersionInformation(FullVersion) ||
147  Second->ReadFullVersionInformation(FullVersion);
148 }
149 
150 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
151  First->ReadModuleName(ModuleName);
152  Second->ReadModuleName(ModuleName);
153 }
154 
155 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
156  First->ReadModuleMapFile(ModuleMapPath);
157  Second->ReadModuleMapFile(ModuleMapPath);
158 }
159 
160 bool
162  bool Complain,
163  bool AllowCompatibleDifferences) {
164  return First->ReadLanguageOptions(LangOpts, Complain,
165  AllowCompatibleDifferences) ||
166  Second->ReadLanguageOptions(LangOpts, Complain,
167  AllowCompatibleDifferences);
168 }
169 
171  const TargetOptions &TargetOpts, bool Complain,
172  bool AllowCompatibleDifferences) {
173  return First->ReadTargetOptions(TargetOpts, Complain,
174  AllowCompatibleDifferences) ||
175  Second->ReadTargetOptions(TargetOpts, Complain,
176  AllowCompatibleDifferences);
177 }
178 
180  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
181  return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
182  Second->ReadDiagnosticOptions(DiagOpts, Complain);
183 }
184 
185 bool
187  bool Complain) {
188  return First->ReadFileSystemOptions(FSOpts, Complain) ||
189  Second->ReadFileSystemOptions(FSOpts, Complain);
190 }
191 
193  const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
194  bool Complain) {
195  return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
196  Complain) ||
197  Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
198  Complain);
199 }
200 
202  const PreprocessorOptions &PPOpts, bool Complain,
203  std::string &SuggestedPredefines) {
204  return First->ReadPreprocessorOptions(PPOpts, Complain,
205  SuggestedPredefines) ||
206  Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
207 }
208 
210  unsigned Value) {
211  First->ReadCounter(M, Value);
212  Second->ReadCounter(M, Value);
213 }
214 
216  return First->needsInputFileVisitation() ||
217  Second->needsInputFileVisitation();
218 }
219 
221  return First->needsSystemInputFileVisitation() ||
222  Second->needsSystemInputFileVisitation();
223 }
224 
226  ModuleKind Kind) {
227  First->visitModuleFile(Filename, Kind);
228  Second->visitModuleFile(Filename, Kind);
229 }
230 
232  bool isSystem,
233  bool isOverridden,
234  bool isExplicitModule) {
235  bool Continue = false;
236  if (First->needsInputFileVisitation() &&
237  (!isSystem || First->needsSystemInputFileVisitation()))
238  Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
239  isExplicitModule);
240  if (Second->needsInputFileVisitation() &&
241  (!isSystem || Second->needsSystemInputFileVisitation()))
242  Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
243  isExplicitModule);
244  return Continue;
245 }
246 
248  const ModuleFileExtensionMetadata &Metadata) {
249  First->readModuleFileExtension(Metadata);
250  Second->readModuleFileExtension(Metadata);
251 }
252 
253 //===----------------------------------------------------------------------===//
254 // PCH validator implementation
255 //===----------------------------------------------------------------------===//
256 
258 
259 /// Compare the given set of language options against an existing set of
260 /// language options.
261 ///
262 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
263 /// \param AllowCompatibleDifferences If true, differences between compatible
264 /// language options will be permitted.
265 ///
266 /// \returns true if the languagae options mis-match, false otherwise.
267 static bool checkLanguageOptions(const LangOptions &LangOpts,
268  const LangOptions &ExistingLangOpts,
269  DiagnosticsEngine *Diags,
270  bool AllowCompatibleDifferences = true) {
271 #define LANGOPT(Name, Bits, Default, Description) \
272  if (ExistingLangOpts.Name != LangOpts.Name) { \
273  if (Diags) \
274  Diags->Report(diag::err_pch_langopt_mismatch) \
275  << Description << LangOpts.Name << ExistingLangOpts.Name; \
276  return true; \
277  }
278 
279 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
280  if (ExistingLangOpts.Name != LangOpts.Name) { \
281  if (Diags) \
282  Diags->Report(diag::err_pch_langopt_value_mismatch) \
283  << Description; \
284  return true; \
285  }
286 
287 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
288  if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
289  if (Diags) \
290  Diags->Report(diag::err_pch_langopt_value_mismatch) \
291  << Description; \
292  return true; \
293  }
294 
295 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
296  if (!AllowCompatibleDifferences) \
297  LANGOPT(Name, Bits, Default, Description)
298 
299 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
300  if (!AllowCompatibleDifferences) \
301  ENUM_LANGOPT(Name, Bits, Default, Description)
302 
303 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
304  if (!AllowCompatibleDifferences) \
305  VALUE_LANGOPT(Name, Bits, Default, Description)
306 
307 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
308 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
309 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
310 #include "clang/Basic/LangOptions.def"
311 
312  if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
313  if (Diags)
314  Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
315  return true;
316  }
317 
318  if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
319  if (Diags)
320  Diags->Report(diag::err_pch_langopt_value_mismatch)
321  << "target Objective-C runtime";
322  return true;
323  }
324 
325  if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
326  LangOpts.CommentOpts.BlockCommandNames) {
327  if (Diags)
328  Diags->Report(diag::err_pch_langopt_value_mismatch)
329  << "block command names";
330  return true;
331  }
332 
333  // Sanitizer feature mismatches are treated as compatible differences. If
334  // compatible differences aren't allowed, we still only want to check for
335  // mismatches of non-modular sanitizers (the only ones which can affect AST
336  // generation).
337  if (!AllowCompatibleDifferences) {
338  SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
339  SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
340  SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
341  ExistingSanitizers.clear(ModularSanitizers);
342  ImportedSanitizers.clear(ModularSanitizers);
343  if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
344  const std::string Flag = "-fsanitize=";
345  if (Diags) {
346 #define SANITIZER(NAME, ID) \
347  { \
348  bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
349  bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
350  if (InExistingModule != InImportedModule) \
351  Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
352  << InExistingModule << (Flag + NAME); \
353  }
354 #include "clang/Basic/Sanitizers.def"
355  }
356  return true;
357  }
358  }
359 
360  return false;
361 }
362 
363 /// Compare the given set of target options against an existing set of
364 /// target options.
365 ///
366 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
367 ///
368 /// \returns true if the target options mis-match, false otherwise.
369 static bool checkTargetOptions(const TargetOptions &TargetOpts,
370  const TargetOptions &ExistingTargetOpts,
371  DiagnosticsEngine *Diags,
372  bool AllowCompatibleDifferences = true) {
373 #define CHECK_TARGET_OPT(Field, Name) \
374  if (TargetOpts.Field != ExistingTargetOpts.Field) { \
375  if (Diags) \
376  Diags->Report(diag::err_pch_targetopt_mismatch) \
377  << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
378  return true; \
379  }
380 
381  // The triple and ABI must match exactly.
382  CHECK_TARGET_OPT(Triple, "target");
383  CHECK_TARGET_OPT(ABI, "target ABI");
384 
385  // We can tolerate different CPUs in many cases, notably when one CPU
386  // supports a strict superset of another. When allowing compatible
387  // differences skip this check.
388  if (!AllowCompatibleDifferences)
389  CHECK_TARGET_OPT(CPU, "target CPU");
390 
391 #undef CHECK_TARGET_OPT
392 
393  // Compare feature sets.
394  SmallVector<StringRef, 4> ExistingFeatures(
395  ExistingTargetOpts.FeaturesAsWritten.begin(),
396  ExistingTargetOpts.FeaturesAsWritten.end());
397  SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
398  TargetOpts.FeaturesAsWritten.end());
399  llvm::sort(ExistingFeatures.begin(), ExistingFeatures.end());
400  llvm::sort(ReadFeatures.begin(), ReadFeatures.end());
401 
402  // We compute the set difference in both directions explicitly so that we can
403  // diagnose the differences differently.
404  SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
405  std::set_difference(
406  ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
407  ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
408  std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
409  ExistingFeatures.begin(), ExistingFeatures.end(),
410  std::back_inserter(UnmatchedReadFeatures));
411 
412  // If we are allowing compatible differences and the read feature set is
413  // a strict subset of the existing feature set, there is nothing to diagnose.
414  if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
415  return false;
416 
417  if (Diags) {
418  for (StringRef Feature : UnmatchedReadFeatures)
419  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
420  << /* is-existing-feature */ false << Feature;
421  for (StringRef Feature : UnmatchedExistingFeatures)
422  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
423  << /* is-existing-feature */ true << Feature;
424  }
425 
426  return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
427 }
428 
429 bool
431  bool Complain,
432  bool AllowCompatibleDifferences) {
433  const LangOptions &ExistingLangOpts = PP.getLangOpts();
434  return checkLanguageOptions(LangOpts, ExistingLangOpts,
435  Complain ? &Reader.Diags : nullptr,
436  AllowCompatibleDifferences);
437 }
438 
440  bool Complain,
441  bool AllowCompatibleDifferences) {
442  const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
443  return checkTargetOptions(TargetOpts, ExistingTargetOpts,
444  Complain ? &Reader.Diags : nullptr,
445  AllowCompatibleDifferences);
446 }
447 
448 namespace {
449 
450 using MacroDefinitionsMap =
451  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
452 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
453 
454 } // namespace
455 
457  DiagnosticsEngine &Diags,
458  bool Complain) {
460 
461  // Check current mappings for new -Werror mappings, and the stored mappings
462  // for cases that were explicitly mapped to *not* be errors that are now
463  // errors because of options like -Werror.
464  DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
465 
466  for (DiagnosticsEngine *MappingSource : MappingSources) {
467  for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
468  diag::kind DiagID = DiagIDMappingPair.first;
469  Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
470  if (CurLevel < DiagnosticsEngine::Error)
471  continue; // not significant
472  Level StoredLevel =
473  StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
474  if (StoredLevel < DiagnosticsEngine::Error) {
475  if (Complain)
476  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
477  Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
478  return true;
479  }
480  }
481  }
482 
483  return false;
484 }
485 
488  if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
489  return true;
490  return Ext >= diag::Severity::Error;
491 }
492 
494  DiagnosticsEngine &Diags,
495  bool IsSystem, bool Complain) {
496  // Top-level options
497  if (IsSystem) {
498  if (Diags.getSuppressSystemWarnings())
499  return false;
500  // If -Wsystem-headers was not enabled before, be conservative
501  if (StoredDiags.getSuppressSystemWarnings()) {
502  if (Complain)
503  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
504  return true;
505  }
506  }
507 
508  if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
509  if (Complain)
510  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
511  return true;
512  }
513 
514  if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
515  !StoredDiags.getEnableAllWarnings()) {
516  if (Complain)
517  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
518  return true;
519  }
520 
521  if (isExtHandlingFromDiagsError(Diags) &&
522  !isExtHandlingFromDiagsError(StoredDiags)) {
523  if (Complain)
524  Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
525  return true;
526  }
527 
528  return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
529 }
530 
531 /// Return the top import module if it is implicit, nullptr otherwise.
533  Preprocessor &PP) {
534  // If the original import came from a file explicitly generated by the user,
535  // don't check the diagnostic mappings.
536  // FIXME: currently this is approximated by checking whether this is not a
537  // module import of an implicitly-loaded module file.
538  // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
539  // the transitive closure of its imports, since unrelated modules cannot be
540  // imported until after this module finishes validation.
541  ModuleFile *TopImport = &*ModuleMgr.rbegin();
542  while (!TopImport->ImportedBy.empty())
543  TopImport = TopImport->ImportedBy[0];
544  if (TopImport->Kind != MK_ImplicitModule)
545  return nullptr;
546 
547  StringRef ModuleName = TopImport->ModuleName;
548  assert(!ModuleName.empty() && "diagnostic options read before module name");
549 
550  Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
551  assert(M && "missing module");
552  return M;
553 }
554 
556  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
557  DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
558  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
560  new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
561  // This should never fail, because we would have processed these options
562  // before writing them to an ASTFile.
563  ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
564 
565  ModuleManager &ModuleMgr = Reader.getModuleManager();
566  assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
567 
568  Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
569  if (!TopM)
570  return false;
571 
572  // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
573  // contains the union of their flags.
574  return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
575  Complain);
576 }
577 
578 /// Collect the macro definitions provided by the given preprocessor
579 /// options.
580 static void
582  MacroDefinitionsMap &Macros,
583  SmallVectorImpl<StringRef> *MacroNames = nullptr) {
584  for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
585  StringRef Macro = PPOpts.Macros[I].first;
586  bool IsUndef = PPOpts.Macros[I].second;
587 
588  std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
589  StringRef MacroName = MacroPair.first;
590  StringRef MacroBody = MacroPair.second;
591 
592  // For an #undef'd macro, we only care about the name.
593  if (IsUndef) {
594  if (MacroNames && !Macros.count(MacroName))
595  MacroNames->push_back(MacroName);
596 
597  Macros[MacroName] = std::make_pair("", true);
598  continue;
599  }
600 
601  // For a #define'd macro, figure out the actual definition.
602  if (MacroName.size() == Macro.size())
603  MacroBody = "1";
604  else {
605  // Note: GCC drops anything following an end-of-line character.
606  StringRef::size_type End = MacroBody.find_first_of("\n\r");
607  MacroBody = MacroBody.substr(0, End);
608  }
609 
610  if (MacroNames && !Macros.count(MacroName))
611  MacroNames->push_back(MacroName);
612  Macros[MacroName] = std::make_pair(MacroBody, false);
613  }
614 }
615 
616 /// Check the preprocessor options deserialized from the control block
617 /// against the preprocessor options in an existing preprocessor.
618 ///
619 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620 /// \param Validate If true, validate preprocessor options. If false, allow
621 /// macros defined by \p ExistingPPOpts to override those defined by
622 /// \p PPOpts in SuggestedPredefines.
624  const PreprocessorOptions &ExistingPPOpts,
625  DiagnosticsEngine *Diags,
626  FileManager &FileMgr,
627  std::string &SuggestedPredefines,
628  const LangOptions &LangOpts,
629  bool Validate = true) {
630  // Check macro definitions.
631  MacroDefinitionsMap ASTFileMacros;
632  collectMacroDefinitions(PPOpts, ASTFileMacros);
633  MacroDefinitionsMap ExistingMacros;
634  SmallVector<StringRef, 4> ExistingMacroNames;
635  collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
636 
637  for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
638  // Dig out the macro definition in the existing preprocessor options.
639  StringRef MacroName = ExistingMacroNames[I];
640  std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
641 
642  // Check whether we know anything about this macro name or not.
643  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
644  ASTFileMacros.find(MacroName);
645  if (!Validate || Known == ASTFileMacros.end()) {
646  // FIXME: Check whether this identifier was referenced anywhere in the
647  // AST file. If so, we should reject the AST file. Unfortunately, this
648  // information isn't in the control block. What shall we do about it?
649 
650  if (Existing.second) {
651  SuggestedPredefines += "#undef ";
652  SuggestedPredefines += MacroName.str();
653  SuggestedPredefines += '\n';
654  } else {
655  SuggestedPredefines += "#define ";
656  SuggestedPredefines += MacroName.str();
657  SuggestedPredefines += ' ';
658  SuggestedPredefines += Existing.first.str();
659  SuggestedPredefines += '\n';
660  }
661  continue;
662  }
663 
664  // If the macro was defined in one but undef'd in the other, we have a
665  // conflict.
666  if (Existing.second != Known->second.second) {
667  if (Diags) {
668  Diags->Report(diag::err_pch_macro_def_undef)
669  << MacroName << Known->second.second;
670  }
671  return true;
672  }
673 
674  // If the macro was #undef'd in both, or if the macro bodies are identical,
675  // it's fine.
676  if (Existing.second || Existing.first == Known->second.first)
677  continue;
678 
679  // The macro bodies differ; complain.
680  if (Diags) {
681  Diags->Report(diag::err_pch_macro_def_conflict)
682  << MacroName << Known->second.first << Existing.first;
683  }
684  return true;
685  }
686 
687  // Check whether we're using predefines.
688  if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
689  if (Diags) {
690  Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
691  }
692  return true;
693  }
694 
695  // Detailed record is important since it is used for the module cache hash.
696  if (LangOpts.Modules &&
697  PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
698  if (Diags) {
699  Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
700  }
701  return true;
702  }
703 
704  // Compute the #include and #include_macros lines we need.
705  for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
706  StringRef File = ExistingPPOpts.Includes[I];
707 
708  if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
709  !ExistingPPOpts.PCHThroughHeader.empty()) {
710  // In case the through header is an include, we must add all the includes
711  // to the predefines so the start point can be determined.
712  SuggestedPredefines += "#include \"";
713  SuggestedPredefines += File;
714  SuggestedPredefines += "\"\n";
715  continue;
716  }
717 
718  if (File == ExistingPPOpts.ImplicitPCHInclude)
719  continue;
720 
721  if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
722  != PPOpts.Includes.end())
723  continue;
724 
725  SuggestedPredefines += "#include \"";
726  SuggestedPredefines += File;
727  SuggestedPredefines += "\"\n";
728  }
729 
730  for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
731  StringRef File = ExistingPPOpts.MacroIncludes[I];
732  if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
733  File)
734  != PPOpts.MacroIncludes.end())
735  continue;
736 
737  SuggestedPredefines += "#__include_macros \"";
738  SuggestedPredefines += File;
739  SuggestedPredefines += "\"\n##\n";
740  }
741 
742  return false;
743 }
744 
746  bool Complain,
747  std::string &SuggestedPredefines) {
748  const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
749 
750  return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
751  Complain? &Reader.Diags : nullptr,
752  PP.getFileManager(),
753  SuggestedPredefines,
754  PP.getLangOpts());
755 }
756 
758  const PreprocessorOptions &PPOpts,
759  bool Complain,
760  std::string &SuggestedPredefines) {
761  return checkPreprocessorOptions(PPOpts,
762  PP.getPreprocessorOpts(),
763  nullptr,
764  PP.getFileManager(),
765  SuggestedPredefines,
766  PP.getLangOpts(),
767  false);
768 }
769 
770 /// Check the header search options deserialized from the control block
771 /// against the header search options in an existing preprocessor.
772 ///
773 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
775  StringRef SpecificModuleCachePath,
776  StringRef ExistingModuleCachePath,
777  DiagnosticsEngine *Diags,
778  const LangOptions &LangOpts) {
779  if (LangOpts.Modules) {
780  if (SpecificModuleCachePath != ExistingModuleCachePath) {
781  if (Diags)
782  Diags->Report(diag::err_pch_modulecache_mismatch)
783  << SpecificModuleCachePath << ExistingModuleCachePath;
784  return true;
785  }
786  }
787 
788  return false;
789 }
790 
792  StringRef SpecificModuleCachePath,
793  bool Complain) {
794  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
795  PP.getHeaderSearchInfo().getModuleCachePath(),
796  Complain ? &Reader.Diags : nullptr,
797  PP.getLangOpts());
798 }
799 
800 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
801  PP.setCounterValue(Value);
802 }
803 
804 //===----------------------------------------------------------------------===//
805 // AST reader implementation
806 //===----------------------------------------------------------------------===//
807 
809  bool TakeOwnership) {
810  DeserializationListener = Listener;
811  OwnsDeserializationListener = TakeOwnership;
812 }
813 
815  return serialization::ComputeHash(Sel);
816 }
817 
818 std::pair<unsigned, unsigned>
820  using namespace llvm::support;
821 
822  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
823  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
824  return std::make_pair(KeyLen, DataLen);
825 }
826 
828 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
829  using namespace llvm::support;
830 
831  SelectorTable &SelTable = Reader.getContext().Selectors;
832  unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
833  IdentifierInfo *FirstII = Reader.getLocalIdentifier(
834  F, endian::readNext<uint32_t, little, unaligned>(d));
835  if (N == 0)
836  return SelTable.getNullarySelector(FirstII);
837  else if (N == 1)
838  return SelTable.getUnarySelector(FirstII);
839 
841  Args.push_back(FirstII);
842  for (unsigned I = 1; I != N; ++I)
843  Args.push_back(Reader.getLocalIdentifier(
844  F, endian::readNext<uint32_t, little, unaligned>(d)));
845 
846  return SelTable.getSelector(N, Args.data());
847 }
848 
851  unsigned DataLen) {
852  using namespace llvm::support;
853 
854  data_type Result;
855 
856  Result.ID = Reader.getGlobalSelectorID(
857  F, endian::readNext<uint32_t, little, unaligned>(d));
858  unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
859  unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
860  Result.InstanceBits = FullInstanceBits & 0x3;
861  Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
862  Result.FactoryBits = FullFactoryBits & 0x3;
863  Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
864  unsigned NumInstanceMethods = FullInstanceBits >> 3;
865  unsigned NumFactoryMethods = FullFactoryBits >> 3;
866 
867  // Load instance methods
868  for (unsigned I = 0; I != NumInstanceMethods; ++I) {
869  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
870  F, endian::readNext<uint32_t, little, unaligned>(d)))
871  Result.Instance.push_back(Method);
872  }
873 
874  // Load factory methods
875  for (unsigned I = 0; I != NumFactoryMethods; ++I) {
876  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
877  F, endian::readNext<uint32_t, little, unaligned>(d)))
878  Result.Factory.push_back(Method);
879  }
880 
881  return Result;
882 }
883 
885  return llvm::djbHash(a);
886 }
887 
888 std::pair<unsigned, unsigned>
890  using namespace llvm::support;
891 
892  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
893  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
894  return std::make_pair(KeyLen, DataLen);
895 }
896 
898 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
899  assert(n >= 2 && d[n-1] == '\0');
900  return StringRef((const char*) d, n-1);
901 }
902 
903 /// Whether the given identifier is "interesting".
905  bool IsModule) {
906  return II.hadMacroDefinition() ||
907  II.isPoisoned() ||
908  (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
910  (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
911  II.getFETokenInfo<void>());
912 }
913 
914 static bool readBit(unsigned &Bits) {
915  bool Value = Bits & 0x1;
916  Bits >>= 1;
917  return Value;
918 }
919 
921  using namespace llvm::support;
922 
923  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
924  return Reader.getGlobalIdentifierID(F, RawID >> 1);
925 }
926 
927 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
928  if (!II.isFromAST()) {
929  II.setIsFromAST();
930  bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
931  if (isInterestingIdentifier(Reader, II, IsModule))
933  }
934 }
935 
937  const unsigned char* d,
938  unsigned DataLen) {
939  using namespace llvm::support;
940 
941  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
942  bool IsInteresting = RawID & 0x01;
943 
944  // Wipe out the "is interesting" bit.
945  RawID = RawID >> 1;
946 
947  // Build the IdentifierInfo and link the identifier ID with it.
948  IdentifierInfo *II = KnownII;
949  if (!II) {
950  II = &Reader.getIdentifierTable().getOwn(k);
951  KnownII = II;
952  }
953  markIdentifierFromAST(Reader, *II);
954  Reader.markIdentifierUpToDate(II);
955 
956  IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
957  if (!IsInteresting) {
958  // For uninteresting identifiers, there's nothing else to do. Just notify
959  // the reader that we've finished loading this identifier.
960  Reader.SetIdentifierInfo(ID, II);
961  return II;
962  }
963 
964  unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
965  unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
966  bool CPlusPlusOperatorKeyword = readBit(Bits);
967  bool HasRevertedTokenIDToIdentifier = readBit(Bits);
968  bool HasRevertedBuiltin = readBit(Bits);
969  bool Poisoned = readBit(Bits);
970  bool ExtensionToken = readBit(Bits);
971  bool HadMacroDefinition = readBit(Bits);
972 
973  assert(Bits == 0 && "Extra bits in the identifier?");
974  DataLen -= 8;
975 
976  // Set or check the various bits in the IdentifierInfo structure.
977  // Token IDs are read-only.
978  if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
980  if (!F.isModule())
981  II->setObjCOrBuiltinID(ObjCOrBuiltinID);
982  else if (HasRevertedBuiltin && II->getBuiltinID()) {
983  II->revertBuiltin();
984  assert((II->hasRevertedBuiltin() ||
985  II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
986  "Incorrect ObjC keyword or builtin ID");
987  }
988  assert(II->isExtensionToken() == ExtensionToken &&
989  "Incorrect extension token flag");
990  (void)ExtensionToken;
991  if (Poisoned)
992  II->setIsPoisoned(true);
993  assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
994  "Incorrect C++ operator keyword flag");
995  (void)CPlusPlusOperatorKeyword;
996 
997  // If this identifier is a macro, deserialize the macro
998  // definition.
999  if (HadMacroDefinition) {
1000  uint32_t MacroDirectivesOffset =
1001  endian::readNext<uint32_t, little, unaligned>(d);
1002  DataLen -= 4;
1003 
1004  Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1005  }
1006 
1007  Reader.SetIdentifierInfo(ID, II);
1008 
1009  // Read all of the declarations visible at global scope with this
1010  // name.
1011  if (DataLen > 0) {
1012  SmallVector<uint32_t, 4> DeclIDs;
1013  for (; DataLen > 0; DataLen -= 4)
1014  DeclIDs.push_back(Reader.getGlobalDeclID(
1015  F, endian::readNext<uint32_t, little, unaligned>(d)));
1016  Reader.SetGloballyVisibleDecls(II, DeclIDs);
1017  }
1018 
1019  return II;
1020 }
1021 
1023  : Kind(Name.getNameKind()) {
1024  switch (Kind) {
1026  Data = (uint64_t)Name.getAsIdentifierInfo();
1027  break;
1031  Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1032  break;
1034  Data = Name.getCXXOverloadedOperator();
1035  break;
1037  Data = (uint64_t)Name.getCXXLiteralIdentifier();
1038  break;
1040  Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1042  break;
1047  Data = 0;
1048  break;
1049  }
1050 }
1051 
1053  llvm::FoldingSetNodeID ID;
1054  ID.AddInteger(Kind);
1055 
1056  switch (Kind) {
1060  ID.AddString(((IdentifierInfo*)Data)->getName());
1061  break;
1065  ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1066  break;
1068  ID.AddInteger((OverloadedOperatorKind)Data);
1069  break;
1074  break;
1075  }
1076 
1077  return ID.ComputeHash();
1078 }
1079 
1080 ModuleFile *
1081 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1082  using namespace llvm::support;
1083 
1084  uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1085  return Reader.getLocalModuleFile(F, ModuleFileID);
1086 }
1087 
1088 std::pair<unsigned, unsigned>
1089 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1090  using namespace llvm::support;
1091 
1092  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1093  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1094  return std::make_pair(KeyLen, DataLen);
1095 }
1096 
1098 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1099  using namespace llvm::support;
1100 
1101  auto Kind = (DeclarationName::NameKind)*d++;
1102  uint64_t Data;
1103  switch (Kind) {
1107  Data = (uint64_t)Reader.getLocalIdentifier(
1108  F, endian::readNext<uint32_t, little, unaligned>(d));
1109  break;
1113  Data =
1114  (uint64_t)Reader.getLocalSelector(
1115  F, endian::readNext<uint32_t, little, unaligned>(
1116  d)).getAsOpaquePtr();
1117  break;
1119  Data = *d++; // OverloadedOperatorKind
1120  break;
1125  Data = 0;
1126  break;
1127  }
1128 
1129  return DeclarationNameKey(Kind, Data);
1130 }
1131 
1132 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1133  const unsigned char *d,
1134  unsigned DataLen,
1135  data_type_builder &Val) {
1136  using namespace llvm::support;
1137 
1138  for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1139  uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1140  Val.insert(Reader.getGlobalDeclID(F, LocalID));
1141  }
1142 }
1143 
1144 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1145  BitstreamCursor &Cursor,
1146  uint64_t Offset,
1147  DeclContext *DC) {
1148  assert(Offset != 0);
1149 
1150  SavedStreamPosition SavedPosition(Cursor);
1151  Cursor.JumpToBit(Offset);
1152 
1153  RecordData Record;
1154  StringRef Blob;
1155  unsigned Code = Cursor.ReadCode();
1156  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1157  if (RecCode != DECL_CONTEXT_LEXICAL) {
1158  Error("Expected lexical block");
1159  return true;
1160  }
1161 
1162  assert(!isa<TranslationUnitDecl>(DC) &&
1163  "expected a TU_UPDATE_LEXICAL record for TU");
1164  // If we are handling a C++ class template instantiation, we can see multiple
1165  // lexical updates for the same record. It's important that we select only one
1166  // of them, so that field numbering works properly. Just pick the first one we
1167  // see.
1168  auto &Lex = LexicalDecls[DC];
1169  if (!Lex.first) {
1170  Lex = std::make_pair(
1171  &M, llvm::makeArrayRef(
1172  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1173  Blob.data()),
1174  Blob.size() / 4));
1175  }
1176  DC->setHasExternalLexicalStorage(true);
1177  return false;
1178 }
1179 
1180 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1181  BitstreamCursor &Cursor,
1182  uint64_t Offset,
1183  DeclID ID) {
1184  assert(Offset != 0);
1185 
1186  SavedStreamPosition SavedPosition(Cursor);
1187  Cursor.JumpToBit(Offset);
1188 
1189  RecordData Record;
1190  StringRef Blob;
1191  unsigned Code = Cursor.ReadCode();
1192  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1193  if (RecCode != DECL_CONTEXT_VISIBLE) {
1194  Error("Expected visible lookup table block");
1195  return true;
1196  }
1197 
1198  // We can't safely determine the primary context yet, so delay attaching the
1199  // lookup table until we're done with recursive deserialization.
1200  auto *Data = (const unsigned char*)Blob.data();
1201  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1202  return false;
1203 }
1204 
1205 void ASTReader::Error(StringRef Msg) const {
1206  Error(diag::err_fe_pch_malformed, Msg);
1207  if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1208  !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1209  Diag(diag::note_module_cache_path)
1210  << PP.getHeaderSearchInfo().getModuleCachePath();
1211  }
1212 }
1213 
1214 void ASTReader::Error(unsigned DiagID,
1215  StringRef Arg1, StringRef Arg2) const {
1216  if (Diags.isDiagnosticInFlight())
1217  Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1218  else
1219  Diag(DiagID) << Arg1 << Arg2;
1220 }
1221 
1222 //===----------------------------------------------------------------------===//
1223 // Source Manager Deserialization
1224 //===----------------------------------------------------------------------===//
1225 
1226 /// Read the line table in the source manager block.
1227 /// \returns true if there was an error.
1228 bool ASTReader::ParseLineTable(ModuleFile &F,
1229  const RecordData &Record) {
1230  unsigned Idx = 0;
1231  LineTableInfo &LineTable = SourceMgr.getLineTable();
1232 
1233  // Parse the file names
1234  std::map<int, int> FileIDs;
1235  FileIDs[-1] = -1; // For unspecified filenames.
1236  for (unsigned I = 0; Record[Idx]; ++I) {
1237  // Extract the file name
1238  auto Filename = ReadPath(F, Record, Idx);
1239  FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1240  }
1241  ++Idx;
1242 
1243  // Parse the line entries
1244  std::vector<LineEntry> Entries;
1245  while (Idx < Record.size()) {
1246  int FID = Record[Idx++];
1247  assert(FID >= 0 && "Serialized line entries for non-local file.");
1248  // Remap FileID from 1-based old view.
1249  FID += F.SLocEntryBaseID - 1;
1250 
1251  // Extract the line entries
1252  unsigned NumEntries = Record[Idx++];
1253  assert(NumEntries && "no line entries for file ID");
1254  Entries.clear();
1255  Entries.reserve(NumEntries);
1256  for (unsigned I = 0; I != NumEntries; ++I) {
1257  unsigned FileOffset = Record[Idx++];
1258  unsigned LineNo = Record[Idx++];
1259  int FilenameID = FileIDs[Record[Idx++]];
1261  = (SrcMgr::CharacteristicKind)Record[Idx++];
1262  unsigned IncludeOffset = Record[Idx++];
1263  Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1264  FileKind, IncludeOffset));
1265  }
1266  LineTable.AddEntry(FileID::get(FID), Entries);
1267  }
1268 
1269  return false;
1270 }
1271 
1272 /// Read a source manager block
1273 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1274  using namespace SrcMgr;
1275 
1276  BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1277 
1278  // Set the source-location entry cursor to the current position in
1279  // the stream. This cursor will be used to read the contents of the
1280  // source manager block initially, and then lazily read
1281  // source-location entries as needed.
1282  SLocEntryCursor = F.Stream;
1283 
1284  // The stream itself is going to skip over the source manager block.
1285  if (F.Stream.SkipBlock()) {
1286  Error("malformed block record in AST file");
1287  return true;
1288  }
1289 
1290  // Enter the source manager block.
1291  if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1292  Error("malformed source manager block record in AST file");
1293  return true;
1294  }
1295 
1296  RecordData Record;
1297  while (true) {
1298  llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1299 
1300  switch (E.Kind) {
1301  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1303  Error("malformed block record in AST file");
1304  return true;
1305  case llvm::BitstreamEntry::EndBlock:
1306  return false;
1307  case llvm::BitstreamEntry::Record:
1308  // The interesting case.
1309  break;
1310  }
1311 
1312  // Read a record.
1313  Record.clear();
1314  StringRef Blob;
1315  switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1316  default: // Default behavior: ignore.
1317  break;
1318 
1319  case SM_SLOC_FILE_ENTRY:
1320  case SM_SLOC_BUFFER_ENTRY:
1322  // Once we hit one of the source location entries, we're done.
1323  return false;
1324  }
1325  }
1326 }
1327 
1328 /// If a header file is not found at the path that we expect it to be
1329 /// and the PCH file was moved from its original location, try to resolve the
1330 /// file by assuming that header+PCH were moved together and the header is in
1331 /// the same place relative to the PCH.
1332 static std::string
1334  const std::string &OriginalDir,
1335  const std::string &CurrDir) {
1336  assert(OriginalDir != CurrDir &&
1337  "No point trying to resolve the file if the PCH dir didn't change");
1338 
1339  using namespace llvm::sys;
1340 
1341  SmallString<128> filePath(Filename);
1342  fs::make_absolute(filePath);
1343  assert(path::is_absolute(OriginalDir));
1344  SmallString<128> currPCHPath(CurrDir);
1345 
1346  path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1347  fileDirE = path::end(path::parent_path(filePath));
1348  path::const_iterator origDirI = path::begin(OriginalDir),
1349  origDirE = path::end(OriginalDir);
1350  // Skip the common path components from filePath and OriginalDir.
1351  while (fileDirI != fileDirE && origDirI != origDirE &&
1352  *fileDirI == *origDirI) {
1353  ++fileDirI;
1354  ++origDirI;
1355  }
1356  for (; origDirI != origDirE; ++origDirI)
1357  path::append(currPCHPath, "..");
1358  path::append(currPCHPath, fileDirI, fileDirE);
1359  path::append(currPCHPath, path::filename(Filename));
1360  return currPCHPath.str();
1361 }
1362 
1364  if (ID == 0)
1365  return false;
1366 
1367  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1368  Error("source location entry ID out-of-range for AST file");
1369  return true;
1370  }
1371 
1372  // Local helper to read the (possibly-compressed) buffer data following the
1373  // entry record.
1374  auto ReadBuffer = [this](
1375  BitstreamCursor &SLocEntryCursor,
1376  StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1377  RecordData Record;
1378  StringRef Blob;
1379  unsigned Code = SLocEntryCursor.ReadCode();
1380  unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1381 
1382  if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1383  if (!llvm::zlib::isAvailable()) {
1384  Error("zlib is not available");
1385  return nullptr;
1386  }
1387  SmallString<0> Uncompressed;
1388  if (llvm::Error E =
1389  llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1390  Error("could not decompress embedded file contents: " +
1391  llvm::toString(std::move(E)));
1392  return nullptr;
1393  }
1394  return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1395  } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1396  return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1397  } else {
1398  Error("AST record has invalid code");
1399  return nullptr;
1400  }
1401  };
1402 
1403  ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1404  F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1405  BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1406  unsigned BaseOffset = F->SLocEntryBaseOffset;
1407 
1408  ++NumSLocEntriesRead;
1409  llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1410  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1411  Error("incorrectly-formatted source location entry in AST file");
1412  return true;
1413  }
1414 
1415  RecordData Record;
1416  StringRef Blob;
1417  switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1418  default:
1419  Error("incorrectly-formatted source location entry in AST file");
1420  return true;
1421 
1422  case SM_SLOC_FILE_ENTRY: {
1423  // We will detect whether a file changed and return 'Failure' for it, but
1424  // we will also try to fail gracefully by setting up the SLocEntry.
1425  unsigned InputID = Record[4];
1426  InputFile IF = getInputFile(*F, InputID);
1427  const FileEntry *File = IF.getFile();
1428  bool OverriddenBuffer = IF.isOverridden();
1429 
1430  // Note that we only check if a File was returned. If it was out-of-date
1431  // we have complained but we will continue creating a FileID to recover
1432  // gracefully.
1433  if (!File)
1434  return true;
1435 
1436  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1437  if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1438  // This is the module's main file.
1439  IncludeLoc = getImportLocation(F);
1440  }
1442  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1443  FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1444  ID, BaseOffset + Record[0]);
1445  SrcMgr::FileInfo &FileInfo =
1446  const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1447  FileInfo.NumCreatedFIDs = Record[5];
1448  if (Record[3])
1449  FileInfo.setHasLineDirectives();
1450 
1451  const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1452  unsigned NumFileDecls = Record[7];
1453  if (NumFileDecls && ContextObj) {
1454  assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1455  FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1456  NumFileDecls));
1457  }
1458 
1459  const SrcMgr::ContentCache *ContentCache
1460  = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1461  if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1462  ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1463  !ContentCache->getRawBuffer()) {
1464  auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1465  if (!Buffer)
1466  return true;
1467  SourceMgr.overrideFileContents(File, std::move(Buffer));
1468  }
1469 
1470  break;
1471  }
1472 
1473  case SM_SLOC_BUFFER_ENTRY: {
1474  const char *Name = Blob.data();
1475  unsigned Offset = Record[0];
1477  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1478  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1479  if (IncludeLoc.isInvalid() && F->isModule()) {
1480  IncludeLoc = getImportLocation(F);
1481  }
1482 
1483  auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1484  if (!Buffer)
1485  return true;
1486  SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1487  BaseOffset + Offset, IncludeLoc);
1488  break;
1489  }
1490 
1491  case SM_SLOC_EXPANSION_ENTRY: {
1492  SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1493  SourceMgr.createExpansionLoc(SpellingLoc,
1494  ReadSourceLocation(*F, Record[2]),
1495  ReadSourceLocation(*F, Record[3]),
1496  Record[5],
1497  Record[4],
1498  ID,
1499  BaseOffset + Record[0]);
1500  break;
1501  }
1502  }
1503 
1504  return false;
1505 }
1506 
1507 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1508  if (ID == 0)
1509  return std::make_pair(SourceLocation(), "");
1510 
1511  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1512  Error("source location entry ID out-of-range for AST file");
1513  return std::make_pair(SourceLocation(), "");
1514  }
1515 
1516  // Find which module file this entry lands in.
1517  ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1518  if (!M->isModule())
1519  return std::make_pair(SourceLocation(), "");
1520 
1521  // FIXME: Can we map this down to a particular submodule? That would be
1522  // ideal.
1523  return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1524 }
1525 
1526 /// Find the location where the module F is imported.
1527 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1528  if (F->ImportLoc.isValid())
1529  return F->ImportLoc;
1530 
1531  // Otherwise we have a PCH. It's considered to be "imported" at the first
1532  // location of its includer.
1533  if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1534  // Main file is the importer.
1535  assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1536  return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1537  }
1538  return F->ImportedBy[0]->FirstLoc;
1539 }
1540 
1541 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1542 /// specified cursor. Read the abbreviations that are at the top of the block
1543 /// and then leave the cursor pointing into the block.
1544 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1545  if (Cursor.EnterSubBlock(BlockID))
1546  return true;
1547 
1548  while (true) {
1549  uint64_t Offset = Cursor.GetCurrentBitNo();
1550  unsigned Code = Cursor.ReadCode();
1551 
1552  // We expect all abbrevs to be at the start of the block.
1553  if (Code != llvm::bitc::DEFINE_ABBREV) {
1554  Cursor.JumpToBit(Offset);
1555  return false;
1556  }
1557  Cursor.ReadAbbrevRecord();
1558  }
1559 }
1560 
1562  unsigned &Idx) {
1563  Token Tok;
1564  Tok.startToken();
1565  Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1566  Tok.setLength(Record[Idx++]);
1567  if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1568  Tok.setIdentifierInfo(II);
1569  Tok.setKind((tok::TokenKind)Record[Idx++]);
1570  Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1571  return Tok;
1572 }
1573 
1575  BitstreamCursor &Stream = F.MacroCursor;
1576 
1577  // Keep track of where we are in the stream, then jump back there
1578  // after reading this macro.
1579  SavedStreamPosition SavedPosition(Stream);
1580 
1581  Stream.JumpToBit(Offset);
1582  RecordData Record;
1584  MacroInfo *Macro = nullptr;
1585 
1586  while (true) {
1587  // Advance to the next record, but if we get to the end of the block, don't
1588  // pop it (removing all the abbreviations from the cursor) since we want to
1589  // be able to reseek within the block and read entries.
1590  unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1591  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1592 
1593  switch (Entry.Kind) {
1594  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1596  Error("malformed block record in AST file");
1597  return Macro;
1598  case llvm::BitstreamEntry::EndBlock:
1599  return Macro;
1600  case llvm::BitstreamEntry::Record:
1601  // The interesting case.
1602  break;
1603  }
1604 
1605  // Read a record.
1606  Record.clear();
1607  PreprocessorRecordTypes RecType =
1608  (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1609  switch (RecType) {
1610  case PP_MODULE_MACRO:
1612  return Macro;
1613 
1614  case PP_MACRO_OBJECT_LIKE:
1615  case PP_MACRO_FUNCTION_LIKE: {
1616  // If we already have a macro, that means that we've hit the end
1617  // of the definition of the macro we were looking for. We're
1618  // done.
1619  if (Macro)
1620  return Macro;
1621 
1622  unsigned NextIndex = 1; // Skip identifier ID.
1623  SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1624  MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1625  MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1626  MI->setIsUsed(Record[NextIndex++]);
1627  MI->setUsedForHeaderGuard(Record[NextIndex++]);
1628 
1629  if (RecType == PP_MACRO_FUNCTION_LIKE) {
1630  // Decode function-like macro info.
1631  bool isC99VarArgs = Record[NextIndex++];
1632  bool isGNUVarArgs = Record[NextIndex++];
1633  bool hasCommaPasting = Record[NextIndex++];
1634  MacroParams.clear();
1635  unsigned NumArgs = Record[NextIndex++];
1636  for (unsigned i = 0; i != NumArgs; ++i)
1637  MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1638 
1639  // Install function-like macro info.
1640  MI->setIsFunctionLike();
1641  if (isC99VarArgs) MI->setIsC99Varargs();
1642  if (isGNUVarArgs) MI->setIsGNUVarargs();
1643  if (hasCommaPasting) MI->setHasCommaPasting();
1644  MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1645  }
1646 
1647  // Remember that we saw this macro last so that we add the tokens that
1648  // form its body to it.
1649  Macro = MI;
1650 
1651  if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1652  Record[NextIndex]) {
1653  // We have a macro definition. Register the association
1655  GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1656  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1657  PreprocessingRecord::PPEntityID PPID =
1658  PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1659  MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1660  PPRec.getPreprocessedEntity(PPID));
1661  if (PPDef)
1662  PPRec.RegisterMacroDefinition(Macro, PPDef);
1663  }
1664 
1665  ++NumMacrosRead;
1666  break;
1667  }
1668 
1669  case PP_TOKEN: {
1670  // If we see a TOKEN before a PP_MACRO_*, then the file is
1671  // erroneous, just pretend we didn't see this.
1672  if (!Macro) break;
1673 
1674  unsigned Idx = 0;
1675  Token Tok = ReadToken(F, Record, Idx);
1676  Macro->AddTokenToBody(Tok);
1677  break;
1678  }
1679  }
1680  }
1681 }
1682 
1685  unsigned LocalID) const {
1686  if (!M.ModuleOffsetMap.empty())
1687  ReadModuleOffsetMap(M);
1688 
1691  assert(I != M.PreprocessedEntityRemap.end()
1692  && "Invalid index into preprocessed entity index remap");
1693 
1694  return LocalID + I->second;
1695 }
1696 
1698  return llvm::hash_combine(ikey.Size, ikey.ModTime);
1699 }
1700 
1702 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1703  internal_key_type ikey = {FE->getSize(),
1704  M.HasTimestamps ? FE->getModificationTime() : 0,
1705  FE->getName(), /*Imported*/ false};
1706  return ikey;
1707 }
1708 
1709 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1710  if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1711  return false;
1712 
1713  if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1714  return true;
1715 
1716  // Determine whether the actual files are equivalent.
1717  FileManager &FileMgr = Reader.getFileManager();
1718  auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1719  if (!Key.Imported)
1720  return FileMgr.getFile(Key.Filename);
1721 
1722  std::string Resolved = Key.Filename;
1723  Reader.ResolveImportedPath(M, Resolved);
1724  return FileMgr.getFile(Resolved);
1725  };
1726 
1727  const FileEntry *FEA = GetFile(a);
1728  const FileEntry *FEB = GetFile(b);
1729  return FEA && FEA == FEB;
1730 }
1731 
1732 std::pair<unsigned, unsigned>
1733 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1734  using namespace llvm::support;
1735 
1736  unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1737  unsigned DataLen = (unsigned) *d++;
1738  return std::make_pair(KeyLen, DataLen);
1739 }
1740 
1742 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1743  using namespace llvm::support;
1744 
1745  internal_key_type ikey;
1746  ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1747  ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1748  ikey.Filename = (const char *)d;
1749  ikey.Imported = true;
1750  return ikey;
1751 }
1752 
1754 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1755  unsigned DataLen) {
1756  using namespace llvm::support;
1757 
1758  const unsigned char *End = d + DataLen;
1759  HeaderFileInfo HFI;
1760  unsigned Flags = *d++;
1761  // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1762  HFI.isImport |= (Flags >> 5) & 0x01;
1763  HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1764  HFI.DirInfo = (Flags >> 1) & 0x07;
1765  HFI.IndexHeaderMapHeader = Flags & 0x01;
1766  // FIXME: Find a better way to handle this. Maybe just store a
1767  // "has been included" flag?
1768  HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1769  HFI.NumIncludes);
1770  HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1771  M, endian::readNext<uint32_t, little, unaligned>(d));
1772  if (unsigned FrameworkOffset =
1773  endian::readNext<uint32_t, little, unaligned>(d)) {
1774  // The framework offset is 1 greater than the actual offset,
1775  // since 0 is used as an indicator for "no framework name".
1776  StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1777  HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1778  }
1779 
1780  assert((End - d) % 4 == 0 &&
1781  "Wrong data length in HeaderFileInfo deserialization");
1782  while (d != End) {
1783  uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1784  auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1785  LocalSMID >>= 2;
1786 
1787  // This header is part of a module. Associate it with the module to enable
1788  // implicit module import.
1789  SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1790  Module *Mod = Reader.getSubmodule(GlobalSMID);
1791  FileManager &FileMgr = Reader.getFileManager();
1792  ModuleMap &ModMap =
1793  Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1794 
1795  std::string Filename = key.Filename;
1796  if (key.Imported)
1797  Reader.ResolveImportedPath(M, Filename);
1798  // FIXME: This is not always the right filename-as-written, but we're not
1799  // going to use this information to rebuild the module, so it doesn't make
1800  // a lot of difference.
1801  Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1802  ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1803  HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1804  }
1805 
1806  // This HeaderFileInfo was externally loaded.
1807  HFI.External = true;
1808  HFI.IsValid = true;
1809  return HFI;
1810 }
1811 
1813  ModuleFile *M,
1814  uint64_t MacroDirectivesOffset) {
1815  assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1816  PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1817 }
1818 
1820  // Note that we are loading defined macros.
1821  Deserializing Macros(this);
1822 
1823  for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1824  BitstreamCursor &MacroCursor = I.MacroCursor;
1825 
1826  // If there was no preprocessor block, skip this file.
1827  if (MacroCursor.getBitcodeBytes().empty())
1828  continue;
1829 
1830  BitstreamCursor Cursor = MacroCursor;
1831  Cursor.JumpToBit(I.MacroStartOffset);
1832 
1833  RecordData Record;
1834  while (true) {
1835  llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1836 
1837  switch (E.Kind) {
1838  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1840  Error("malformed block record in AST file");
1841  return;
1842  case llvm::BitstreamEntry::EndBlock:
1843  goto NextCursor;
1844 
1845  case llvm::BitstreamEntry::Record:
1846  Record.clear();
1847  switch (Cursor.readRecord(E.ID, Record)) {
1848  default: // Default behavior: ignore.
1849  break;
1850 
1851  case PP_MACRO_OBJECT_LIKE:
1852  case PP_MACRO_FUNCTION_LIKE: {
1853  IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1854  if (II->isOutOfDate())
1855  updateOutOfDateIdentifier(*II);
1856  break;
1857  }
1858 
1859  case PP_TOKEN:
1860  // Ignore tokens.
1861  break;
1862  }
1863  break;
1864  }
1865  }
1866  NextCursor: ;
1867  }
1868 }
1869 
1870 namespace {
1871 
1872  /// Visitor class used to look up identifirs in an AST file.
1873  class IdentifierLookupVisitor {
1874  StringRef Name;
1875  unsigned NameHash;
1876  unsigned PriorGeneration;
1877  unsigned &NumIdentifierLookups;
1878  unsigned &NumIdentifierLookupHits;
1879  IdentifierInfo *Found = nullptr;
1880 
1881  public:
1882  IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1883  unsigned &NumIdentifierLookups,
1884  unsigned &NumIdentifierLookupHits)
1885  : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1886  PriorGeneration(PriorGeneration),
1887  NumIdentifierLookups(NumIdentifierLookups),
1888  NumIdentifierLookupHits(NumIdentifierLookupHits) {}
1889 
1890  bool operator()(ModuleFile &M) {
1891  // If we've already searched this module file, skip it now.
1892  if (M.Generation <= PriorGeneration)
1893  return true;
1894 
1895  ASTIdentifierLookupTable *IdTable
1897  if (!IdTable)
1898  return false;
1899 
1900  ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1901  Found);
1902  ++NumIdentifierLookups;
1903  ASTIdentifierLookupTable::iterator Pos =
1904  IdTable->find_hashed(Name, NameHash, &Trait);
1905  if (Pos == IdTable->end())
1906  return false;
1907 
1908  // Dereferencing the iterator has the effect of building the
1909  // IdentifierInfo node and populating it with the various
1910  // declarations it needs.
1911  ++NumIdentifierLookupHits;
1912  Found = *Pos;
1913  return true;
1914  }
1915 
1916  // Retrieve the identifier info found within the module
1917  // files.
1918  IdentifierInfo *getIdentifierInfo() const { return Found; }
1919  };
1920 
1921 } // namespace
1922 
1924  // Note that we are loading an identifier.
1925  Deserializing AnIdentifier(this);
1926 
1927  unsigned PriorGeneration = 0;
1928  if (getContext().getLangOpts().Modules)
1929  PriorGeneration = IdentifierGeneration[&II];
1930 
1931  // If there is a global index, look there first to determine which modules
1932  // provably do not have any results for this identifier.
1934  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1935  if (!loadGlobalIndex()) {
1936  if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1937  HitsPtr = &Hits;
1938  }
1939  }
1940 
1941  IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1942  NumIdentifierLookups,
1943  NumIdentifierLookupHits);
1944  ModuleMgr.visit(Visitor, HitsPtr);
1945  markIdentifierUpToDate(&II);
1946 }
1947 
1949  if (!II)
1950  return;
1951 
1952  II->setOutOfDate(false);
1953 
1954  // Update the generation for this identifier.
1955  if (getContext().getLangOpts().Modules)
1956  IdentifierGeneration[II] = getGeneration();
1957 }
1958 
1960  const PendingMacroInfo &PMInfo) {
1961  ModuleFile &M = *PMInfo.M;
1962 
1963  BitstreamCursor &Cursor = M.MacroCursor;
1964  SavedStreamPosition SavedPosition(Cursor);
1965  Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1966 
1967  struct ModuleMacroRecord {
1968  SubmoduleID SubModID;
1969  MacroInfo *MI;
1970  SmallVector<SubmoduleID, 8> Overrides;
1971  };
1973 
1974  // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1975  // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1976  // macro histroy.
1977  RecordData Record;
1978  while (true) {
1979  llvm::BitstreamEntry Entry =
1980  Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1981  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1982  Error("malformed block record in AST file");
1983  return;
1984  }
1985 
1986  Record.clear();
1987  switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1989  break;
1990 
1991  case PP_MODULE_MACRO: {
1992  ModuleMacros.push_back(ModuleMacroRecord());
1993  auto &Info = ModuleMacros.back();
1994  Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1995  Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1996  for (int I = 2, N = Record.size(); I != N; ++I)
1997  Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1998  continue;
1999  }
2000 
2001  default:
2002  Error("malformed block record in AST file");
2003  return;
2004  }
2005 
2006  // We found the macro directive history; that's the last record
2007  // for this macro.
2008  break;
2009  }
2010 
2011  // Module macros are listed in reverse dependency order.
2012  {
2013  std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2015  for (auto &MMR : ModuleMacros) {
2016  Overrides.clear();
2017  for (unsigned ModID : MMR.Overrides) {
2018  Module *Mod = getSubmodule(ModID);
2019  auto *Macro = PP.getModuleMacro(Mod, II);
2020  assert(Macro && "missing definition for overridden macro");
2021  Overrides.push_back(Macro);
2022  }
2023 
2024  bool Inserted = false;
2025  Module *Owner = getSubmodule(MMR.SubModID);
2026  PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2027  }
2028  }
2029 
2030  // Don't read the directive history for a module; we don't have anywhere
2031  // to put it.
2032  if (M.isModule())
2033  return;
2034 
2035  // Deserialize the macro directives history in reverse source-order.
2036  MacroDirective *Latest = nullptr, *Earliest = nullptr;
2037  unsigned Idx = 0, N = Record.size();
2038  while (Idx < N) {
2039  MacroDirective *MD = nullptr;
2040  SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2041  MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2042  switch (K) {
2044  MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2045  MD = PP.AllocateDefMacroDirective(MI, Loc);
2046  break;
2047  }
2049  MD = PP.AllocateUndefMacroDirective(Loc);
2050  break;
2052  bool isPublic = Record[Idx++];
2053  MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2054  break;
2055  }
2056 
2057  if (!Latest)
2058  Latest = MD;
2059  if (Earliest)
2060  Earliest->setPrevious(MD);
2061  Earliest = MD;
2062  }
2063 
2064  if (Latest)
2065  PP.setLoadedMacroDirective(II, Earliest, Latest);
2066 }
2067 
2068 ASTReader::InputFileInfo
2069 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2070  // Go find this input file.
2071  BitstreamCursor &Cursor = F.InputFilesCursor;
2072  SavedStreamPosition SavedPosition(Cursor);
2073  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2074 
2075  unsigned Code = Cursor.ReadCode();
2076  RecordData Record;
2077  StringRef Blob;
2078 
2079  unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2080  assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2081  "invalid record type for input file");
2082  (void)Result;
2083 
2084  assert(Record[0] == ID && "Bogus stored ID or offset");
2085  InputFileInfo R;
2086  R.StoredSize = static_cast<off_t>(Record[1]);
2087  R.StoredTime = static_cast<time_t>(Record[2]);
2088  R.Overridden = static_cast<bool>(Record[3]);
2089  R.Transient = static_cast<bool>(Record[4]);
2090  R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2091  R.Filename = Blob;
2092  ResolveImportedPath(F, R.Filename);
2093  return R;
2094 }
2095 
2096 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2097 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2098  // If this ID is bogus, just return an empty input file.
2099  if (ID == 0 || ID > F.InputFilesLoaded.size())
2100  return InputFile();
2101 
2102  // If we've already loaded this input file, return it.
2103  if (F.InputFilesLoaded[ID-1].getFile())
2104  return F.InputFilesLoaded[ID-1];
2105 
2106  if (F.InputFilesLoaded[ID-1].isNotFound())
2107  return InputFile();
2108 
2109  // Go find this input file.
2110  BitstreamCursor &Cursor = F.InputFilesCursor;
2111  SavedStreamPosition SavedPosition(Cursor);
2112  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2113 
2114  InputFileInfo FI = readInputFileInfo(F, ID);
2115  off_t StoredSize = FI.StoredSize;
2116  time_t StoredTime = FI.StoredTime;
2117  bool Overridden = FI.Overridden;
2118  bool Transient = FI.Transient;
2119  StringRef Filename = FI.Filename;
2120 
2121  const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2122  // If we didn't find the file, resolve it relative to the
2123  // original directory from which this AST file was created.
2124  if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2125  F.OriginalDir != F.BaseDirectory) {
2126  std::string Resolved = resolveFileRelativeToOriginalDir(
2127  Filename, F.OriginalDir, F.BaseDirectory);
2128  if (!Resolved.empty())
2129  File = FileMgr.getFile(Resolved);
2130  }
2131 
2132  // For an overridden file, create a virtual file with the stored
2133  // size/timestamp.
2134  if ((Overridden || Transient) && File == nullptr)
2135  File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2136 
2137  if (File == nullptr) {
2138  if (Complain) {
2139  std::string ErrorStr = "could not find file '";
2140  ErrorStr += Filename;
2141  ErrorStr += "' referenced by AST file '";
2142  ErrorStr += F.FileName;
2143  ErrorStr += "'";
2144  Error(ErrorStr);
2145  }
2146  // Record that we didn't find the file.
2148  return InputFile();
2149  }
2150 
2151  // Check if there was a request to override the contents of the file
2152  // that was part of the precompiled header. Overriding such a file
2153  // can lead to problems when lexing using the source locations from the
2154  // PCH.
2155  SourceManager &SM = getSourceManager();
2156  // FIXME: Reject if the overrides are different.
2157  if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2158  if (Complain)
2159  Error(diag::err_fe_pch_file_overridden, Filename);
2160  // After emitting the diagnostic, recover by disabling the override so
2161  // that the original file will be used.
2162  //
2163  // FIXME: This recovery is just as broken as the original state; there may
2164  // be another precompiled module that's using the overridden contents, or
2165  // we might be half way through parsing it. Instead, we should treat the
2166  // overridden contents as belonging to a separate FileEntry.
2167  SM.disableFileContentsOverride(File);
2168  // The FileEntry is a virtual file entry with the size of the contents
2169  // that would override the original contents. Set it to the original's
2170  // size/time.
2171  FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2172  StoredSize, StoredTime);
2173  }
2174 
2175  bool IsOutOfDate = false;
2176 
2177  // For an overridden file, there is nothing to validate.
2178  if (!Overridden && //
2179  (StoredSize != File->getSize() ||
2180  (StoredTime && StoredTime != File->getModificationTime() &&
2181  !DisableValidation)
2182  )) {
2183  if (Complain) {
2184  // Build a list of the PCH imports that got us here (in reverse).
2185  SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2186  while (!ImportStack.back()->ImportedBy.empty())
2187  ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2188 
2189  // The top-level PCH is stale.
2190  StringRef TopLevelPCHName(ImportStack.back()->FileName);
2191  unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2192  if (DiagnosticKind == 0)
2193  Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2194  else if (DiagnosticKind == 1)
2195  Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2196  else
2197  Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2198 
2199  // Print the import stack.
2200  if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2201  Diag(diag::note_pch_required_by)
2202  << Filename << ImportStack[0]->FileName;
2203  for (unsigned I = 1; I < ImportStack.size(); ++I)
2204  Diag(diag::note_pch_required_by)
2205  << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2206  }
2207 
2208  if (!Diags.isDiagnosticInFlight())
2209  Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2210  }
2211 
2212  IsOutOfDate = true;
2213  }
2214  // FIXME: If the file is overridden and we've already opened it,
2215  // issue an error (or split it into a separate FileEntry).
2216 
2217  InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2218 
2219  // Note that we've loaded this input file.
2220  F.InputFilesLoaded[ID-1] = IF;
2221  return IF;
2222 }
2223 
2224 /// If we are loading a relocatable PCH or module file, and the filename
2225 /// is not an absolute path, add the system or module root to the beginning of
2226 /// the file name.
2228  // Resolve relative to the base directory, if we have one.
2229  if (!M.BaseDirectory.empty())
2230  return ResolveImportedPath(Filename, M.BaseDirectory);
2231 }
2232 
2233 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2234  if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2235  return;
2236 
2237  SmallString<128> Buffer;
2238  llvm::sys::path::append(Buffer, Prefix, Filename);
2239  Filename.assign(Buffer.begin(), Buffer.end());
2240 }
2241 
2242 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2243  switch (ARR) {
2244  case ASTReader::Failure: return true;
2245  case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2246  case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2249  return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2250  case ASTReader::HadErrors: return true;
2251  case ASTReader::Success: return false;
2252  }
2253 
2254  llvm_unreachable("unknown ASTReadResult");
2255 }
2256 
2257 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2258  BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2259  bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2260  std::string &SuggestedPredefines) {
2261  if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2262  return Failure;
2263 
2264  // Read all of the records in the options block.
2265  RecordData Record;
2266  ASTReadResult Result = Success;
2267  while (true) {
2268  llvm::BitstreamEntry Entry = Stream.advance();
2269 
2270  switch (Entry.Kind) {
2272  case llvm::BitstreamEntry::SubBlock:
2273  return Failure;
2274 
2275  case llvm::BitstreamEntry::EndBlock:
2276  return Result;
2277 
2278  case llvm::BitstreamEntry::Record:
2279  // The interesting case.
2280  break;
2281  }
2282 
2283  // Read and process a record.
2284  Record.clear();
2285  switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2286  case LANGUAGE_OPTIONS: {
2287  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2288  if (ParseLanguageOptions(Record, Complain, Listener,
2289  AllowCompatibleConfigurationMismatch))
2290  Result = ConfigurationMismatch;
2291  break;
2292  }
2293 
2294  case TARGET_OPTIONS: {
2295  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2296  if (ParseTargetOptions(Record, Complain, Listener,
2297  AllowCompatibleConfigurationMismatch))
2298  Result = ConfigurationMismatch;
2299  break;
2300  }
2301 
2302  case FILE_SYSTEM_OPTIONS: {
2303  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2304  if (!AllowCompatibleConfigurationMismatch &&
2305  ParseFileSystemOptions(Record, Complain, Listener))
2306  Result = ConfigurationMismatch;
2307  break;
2308  }
2309 
2310  case HEADER_SEARCH_OPTIONS: {
2311  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2312  if (!AllowCompatibleConfigurationMismatch &&
2313  ParseHeaderSearchOptions(Record, Complain, Listener))
2314  Result = ConfigurationMismatch;
2315  break;
2316  }
2317 
2318  case PREPROCESSOR_OPTIONS:
2319  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2320  if (!AllowCompatibleConfigurationMismatch &&
2321  ParsePreprocessorOptions(Record, Complain, Listener,
2322  SuggestedPredefines))
2323  Result = ConfigurationMismatch;
2324  break;
2325  }
2326  }
2327 }
2328 
2330 ASTReader::ReadControlBlock(ModuleFile &F,
2332  const ModuleFile *ImportedBy,
2333  unsigned ClientLoadCapabilities) {
2334  BitstreamCursor &Stream = F.Stream;
2335  ASTReadResult Result = Success;
2336 
2337  if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2338  Error("malformed block record in AST file");
2339  return Failure;
2340  }
2341 
2342  // Lambda to read the unhashed control block the first time it's called.
2343  //
2344  // For PCM files, the unhashed control block cannot be read until after the
2345  // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2346  // need to look ahead before reading the IMPORTS record. For consistency,
2347  // this block is always read somehow (see BitstreamEntry::EndBlock).
2348  bool HasReadUnhashedControlBlock = false;
2349  auto readUnhashedControlBlockOnce = [&]() {
2350  if (!HasReadUnhashedControlBlock) {
2351  HasReadUnhashedControlBlock = true;
2352  if (ASTReadResult Result =
2353  readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2354  return Result;
2355  }
2356  return Success;
2357  };
2358 
2359  // Read all of the records and blocks in the control block.
2360  RecordData Record;
2361  unsigned NumInputs = 0;
2362  unsigned NumUserInputs = 0;
2363  while (true) {
2364  llvm::BitstreamEntry Entry = Stream.advance();
2365 
2366  switch (Entry.Kind) {
2368  Error("malformed block record in AST file");
2369  return Failure;
2370  case llvm::BitstreamEntry::EndBlock: {
2371  // Validate the module before returning. This call catches an AST with
2372  // no module name and no imports.
2373  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2374  return Result;
2375 
2376  // Validate input files.
2377  const HeaderSearchOptions &HSOpts =
2378  PP.getHeaderSearchInfo().getHeaderSearchOpts();
2379 
2380  // All user input files reside at the index range [0, NumUserInputs), and
2381  // system input files reside at [NumUserInputs, NumInputs). For explicitly
2382  // loaded module files, ignore missing inputs.
2383  if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2384  F.Kind != MK_PrebuiltModule) {
2385  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2386 
2387  // If we are reading a module, we will create a verification timestamp,
2388  // so we verify all input files. Otherwise, verify only user input
2389  // files.
2390 
2391  unsigned N = NumUserInputs;
2392  if (ValidateSystemInputs ||
2395  F.Kind == MK_ImplicitModule))
2396  N = NumInputs;
2397 
2398  for (unsigned I = 0; I < N; ++I) {
2399  InputFile IF = getInputFile(F, I+1, Complain);
2400  if (!IF.getFile() || IF.isOutOfDate())
2401  return OutOfDate;
2402  }
2403  }
2404 
2405  if (Listener)
2406  Listener->visitModuleFile(F.FileName, F.Kind);
2407 
2408  if (Listener && Listener->needsInputFileVisitation()) {
2409  unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2410  : NumUserInputs;
2411  for (unsigned I = 0; I < N; ++I) {
2412  bool IsSystem = I >= NumUserInputs;
2413  InputFileInfo FI = readInputFileInfo(F, I+1);
2414  Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2415  F.Kind == MK_ExplicitModule ||
2416  F.Kind == MK_PrebuiltModule);
2417  }
2418  }
2419 
2420  return Result;
2421  }
2422 
2423  case llvm::BitstreamEntry::SubBlock:
2424  switch (Entry.ID) {
2425  case INPUT_FILES_BLOCK_ID:
2426  F.InputFilesCursor = Stream;
2427  if (Stream.SkipBlock() || // Skip with the main cursor
2428  // Read the abbreviations
2429  ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2430  Error("malformed block record in AST file");
2431  return Failure;
2432  }
2433  continue;
2434 
2435  case OPTIONS_BLOCK_ID:
2436  // If we're reading the first module for this group, check its options
2437  // are compatible with ours. For modules it imports, no further checking
2438  // is required, because we checked them when we built it.
2439  if (Listener && !ImportedBy) {
2440  // Should we allow the configuration of the module file to differ from
2441  // the configuration of the current translation unit in a compatible
2442  // way?
2443  //
2444  // FIXME: Allow this for files explicitly specified with -include-pch.
2445  bool AllowCompatibleConfigurationMismatch =
2447 
2448  Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2449  AllowCompatibleConfigurationMismatch,
2450  *Listener, SuggestedPredefines);
2451  if (Result == Failure) {
2452  Error("malformed block record in AST file");
2453  return Result;
2454  }
2455 
2456  if (DisableValidation ||
2457  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2458  Result = Success;
2459 
2460  // If we can't load the module, exit early since we likely
2461  // will rebuild the module anyway. The stream may be in the
2462  // middle of a block.
2463  if (Result != Success)
2464  return Result;
2465  } else if (Stream.SkipBlock()) {
2466  Error("malformed block record in AST file");
2467  return Failure;
2468  }
2469  continue;
2470 
2471  default:
2472  if (Stream.SkipBlock()) {
2473  Error("malformed block record in AST file");
2474  return Failure;
2475  }
2476  continue;
2477  }
2478 
2479  case llvm::BitstreamEntry::Record:
2480  // The interesting case.
2481  break;
2482  }
2483 
2484  // Read and process a record.
2485  Record.clear();
2486  StringRef Blob;
2487  switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2488  case METADATA: {
2489  if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2490  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2491  Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2492  : diag::err_pch_version_too_new);
2493  return VersionMismatch;
2494  }
2495 
2496  bool hasErrors = Record[7];
2497  if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2498  Diag(diag::err_pch_with_compiler_errors);
2499  return HadErrors;
2500  }
2501  if (hasErrors) {
2502  Diags.ErrorOccurred = true;
2503  Diags.UncompilableErrorOccurred = true;
2504  Diags.UnrecoverableErrorOccurred = true;
2505  }
2506 
2507  F.RelocatablePCH = Record[4];
2508  // Relative paths in a relocatable PCH are relative to our sysroot.
2509  if (F.RelocatablePCH)
2510  F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2511 
2512  F.HasTimestamps = Record[5];
2513 
2514  F.PCHHasObjectFile = Record[6];
2515 
2516  const std::string &CurBranch = getClangFullRepositoryVersion();
2517  StringRef ASTBranch = Blob;
2518  if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2519  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2520  Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2521  return VersionMismatch;
2522  }
2523  break;
2524  }
2525 
2526  case IMPORTS: {
2527  // Validate the AST before processing any imports (otherwise, untangling
2528  // them can be error-prone and expensive). A module will have a name and
2529  // will already have been validated, but this catches the PCH case.
2530  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2531  return Result;
2532 
2533  // Load each of the imported PCH files.
2534  unsigned Idx = 0, N = Record.size();
2535  while (Idx < N) {
2536  // Read information about the AST file.
2537  ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2538  // The import location will be the local one for now; we will adjust
2539  // all import locations of module imports after the global source
2540  // location info are setup, in ReadAST.
2541  SourceLocation ImportLoc =
2542  ReadUntranslatedSourceLocation(Record[Idx++]);
2543  off_t StoredSize = (off_t)Record[Idx++];
2544  time_t StoredModTime = (time_t)Record[Idx++];
2545  ASTFileSignature StoredSignature = {
2546  {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2547  (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2548  (uint32_t)Record[Idx++]}}};
2549 
2550  std::string ImportedName = ReadString(Record, Idx);
2551  std::string ImportedFile;
2552 
2553  // For prebuilt and explicit modules first consult the file map for
2554  // an override. Note that here we don't search prebuilt module
2555  // directories, only the explicit name to file mappings. Also, we will
2556  // still verify the size/signature making sure it is essentially the
2557  // same file but perhaps in a different location.
2558  if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2559  ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2560  ImportedName, /*FileMapOnly*/ true);
2561 
2562  if (ImportedFile.empty())
2563  ImportedFile = ReadPath(F, Record, Idx);
2564  else
2565  SkipPath(Record, Idx);
2566 
2567  // If our client can't cope with us being out of date, we can't cope with
2568  // our dependency being missing.
2569  unsigned Capabilities = ClientLoadCapabilities;
2570  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2571  Capabilities &= ~ARR_Missing;
2572 
2573  // Load the AST file.
2574  auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2575  Loaded, StoredSize, StoredModTime,
2576  StoredSignature, Capabilities);
2577 
2578  // If we diagnosed a problem, produce a backtrace.
2579  if (isDiagnosedResult(Result, Capabilities))
2580  Diag(diag::note_module_file_imported_by)
2581  << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2582 
2583  switch (Result) {
2584  case Failure: return Failure;
2585  // If we have to ignore the dependency, we'll have to ignore this too.
2586  case Missing:
2587  case OutOfDate: return OutOfDate;
2588  case VersionMismatch: return VersionMismatch;
2589  case ConfigurationMismatch: return ConfigurationMismatch;
2590  case HadErrors: return HadErrors;
2591  case Success: break;
2592  }
2593  }
2594  break;
2595  }
2596 
2597  case ORIGINAL_FILE:
2598  F.OriginalSourceFileID = FileID::get(Record[0]);
2601  ResolveImportedPath(F, F.OriginalSourceFileName);
2602  break;
2603 
2604  case ORIGINAL_FILE_ID:
2605  F.OriginalSourceFileID = FileID::get(Record[0]);
2606  break;
2607 
2608  case ORIGINAL_PCH_DIR:
2609  F.OriginalDir = Blob;
2610  break;
2611 
2612  case MODULE_NAME:
2613  F.ModuleName = Blob;
2614  if (Listener)
2615  Listener->ReadModuleName(F.ModuleName);
2616 
2617  // Validate the AST as soon as we have a name so we can exit early on
2618  // failure.
2619  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2620  return Result;
2621 
2622  break;
2623 
2624  case MODULE_DIRECTORY: {
2625  assert(!F.ModuleName.empty() &&
2626  "MODULE_DIRECTORY found before MODULE_NAME");
2627  // If we've already loaded a module map file covering this module, we may
2628  // have a better path for it (relative to the current build).
2629  Module *M = PP.getHeaderSearchInfo().lookupModule(
2630  F.ModuleName, /*AllowSearch*/ true,
2631  /*AllowExtraModuleMapSearch*/ true);
2632  if (M && M->Directory) {
2633  // If we're implicitly loading a module, the base directory can't
2634  // change between the build and use.
2635  // Don't emit module relocation error if we have -fno-validate-pch
2636  if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2638  const DirectoryEntry *BuildDir =
2639  PP.getFileManager().getDirectory(Blob);
2640  if (!BuildDir || BuildDir != M->Directory) {
2641  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2642  Diag(diag::err_imported_module_relocated)
2643  << F.ModuleName << Blob << M->Directory->getName();
2644  return OutOfDate;
2645  }
2646  }
2647  F.BaseDirectory = M->Directory->getName();
2648  } else {
2649  F.BaseDirectory = Blob;
2650  }
2651  break;
2652  }
2653 
2654  case MODULE_MAP_FILE:
2655  if (ASTReadResult Result =
2656  ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2657  return Result;
2658  break;
2659 
2660  case INPUT_FILE_OFFSETS:
2661  NumInputs = Record[0];
2662  NumUserInputs = Record[1];
2663  F.InputFileOffsets =
2664  (const llvm::support::unaligned_uint64_t *)Blob.data();
2665  F.InputFilesLoaded.resize(NumInputs);
2666  F.NumUserInputFiles = NumUserInputs;
2667  break;
2668  }
2669  }
2670 }
2671 
2673 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2674  BitstreamCursor &Stream = F.Stream;
2675 
2676  if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2677  Error("malformed block record in AST file");
2678  return Failure;
2679  }
2680 
2681  // Read all of the records and blocks for the AST file.
2682  RecordData Record;
2683  while (true) {
2684  llvm::BitstreamEntry Entry = Stream.advance();
2685 
2686  switch (Entry.Kind) {
2688  Error("error at end of module block in AST file");
2689  return Failure;
2690  case llvm::BitstreamEntry::EndBlock:
2691  // Outside of C++, we do not store a lookup map for the translation unit.
2692  // Instead, mark it as needing a lookup map to be built if this module
2693  // contains any declarations lexically within it (which it always does!).
2694  // This usually has no cost, since we very rarely need the lookup map for
2695  // the translation unit outside C++.
2696  if (ASTContext *Ctx = ContextObj) {
2697  DeclContext *DC = Ctx->getTranslationUnitDecl();
2698  if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2700  }
2701 
2702  return Success;
2703  case llvm::BitstreamEntry::SubBlock:
2704  switch (Entry.ID) {
2705  case DECLTYPES_BLOCK_ID:
2706  // We lazily load the decls block, but we want to set up the
2707  // DeclsCursor cursor to point into it. Clone our current bitcode
2708  // cursor to it, enter the block and read the abbrevs in that block.
2709  // With the main cursor, we just skip over it.
2710  F.DeclsCursor = Stream;
2711  if (Stream.SkipBlock() || // Skip with the main cursor.
2712  // Read the abbrevs.
2713  ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2714  Error("malformed block record in AST file");
2715  return Failure;
2716  }
2717  break;
2718 
2719  case PREPROCESSOR_BLOCK_ID:
2720  F.MacroCursor = Stream;
2721  if (!PP.getExternalSource())
2722  PP.setExternalSource(this);
2723 
2724  if (Stream.SkipBlock() ||
2725  ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2726  Error("malformed block record in AST file");
2727  return Failure;
2728  }
2729  F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2730  break;
2731 
2733  F.PreprocessorDetailCursor = Stream;
2734  if (Stream.SkipBlock() ||
2735  ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2737  Error("malformed preprocessor detail record in AST file");
2738  return Failure;
2739  }
2741  = F.PreprocessorDetailCursor.GetCurrentBitNo();
2742 
2743  if (!PP.getPreprocessingRecord())
2744  PP.createPreprocessingRecord();
2745  if (!PP.getPreprocessingRecord()->getExternalSource())
2746  PP.getPreprocessingRecord()->SetExternalSource(*this);
2747  break;
2748 
2750  if (ReadSourceManagerBlock(F))
2751  return Failure;
2752  break;
2753 
2754  case SUBMODULE_BLOCK_ID:
2755  if (ASTReadResult Result =
2756  ReadSubmoduleBlock(F, ClientLoadCapabilities))
2757  return Result;
2758  break;
2759 
2760  case COMMENTS_BLOCK_ID: {
2761  BitstreamCursor C = Stream;
2762  if (Stream.SkipBlock() ||
2763  ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2764  Error("malformed comments block in AST file");
2765  return Failure;
2766  }
2767  CommentsCursors.push_back(std::make_pair(C, &F));
2768  break;
2769  }
2770 
2771  default:
2772  if (Stream.SkipBlock()) {
2773  Error("malformed block record in AST file");
2774  return Failure;
2775  }
2776  break;
2777  }
2778  continue;
2779 
2780  case llvm::BitstreamEntry::Record:
2781  // The interesting case.
2782  break;
2783  }
2784 
2785  // Read and process a record.
2786  Record.clear();
2787  StringRef Blob;
2788  auto RecordType =
2789  (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2790 
2791  // If we're not loading an AST context, we don't care about most records.
2792  if (!ContextObj) {
2793  switch (RecordType) {
2794  case IDENTIFIER_TABLE:
2795  case IDENTIFIER_OFFSET:
2797  case STATISTICS:
2798  case PP_CONDITIONAL_STACK:
2799  case PP_COUNTER_VALUE:
2801  case MODULE_OFFSET_MAP:
2804  case PPD_ENTITIES_OFFSETS:
2805  case HEADER_SEARCH_TABLE:
2806  case IMPORTED_MODULES:
2807  case MACRO_OFFSET:
2808  break;
2809  default:
2810  continue;
2811  }
2812  }
2813 
2814  switch (RecordType) {
2815  default: // Default behavior: ignore.
2816  break;
2817 
2818  case TYPE_OFFSET: {
2819  if (F.LocalNumTypes != 0) {
2820  Error("duplicate TYPE_OFFSET record in AST file");
2821  return Failure;
2822  }
2823  F.TypeOffsets = (const uint32_t *)Blob.data();
2824  F.LocalNumTypes = Record[0];
2825  unsigned LocalBaseTypeIndex = Record[1];
2826  F.BaseTypeIndex = getTotalNumTypes();
2827 
2828  if (F.LocalNumTypes > 0) {
2829  // Introduce the global -> local mapping for types within this module.
2830  GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2831 
2832  // Introduce the local -> global mapping for types within this module.
2834  std::make_pair(LocalBaseTypeIndex,
2835  F.BaseTypeIndex - LocalBaseTypeIndex));
2836 
2837  TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2838  }
2839  break;
2840  }
2841 
2842  case DECL_OFFSET: {
2843  if (F.LocalNumDecls != 0) {
2844  Error("duplicate DECL_OFFSET record in AST file");
2845  return Failure;
2846  }
2847  F.DeclOffsets = (const DeclOffset *)Blob.data();
2848  F.LocalNumDecls = Record[0];
2849  unsigned LocalBaseDeclID = Record[1];
2850  F.BaseDeclID = getTotalNumDecls();
2851 
2852  if (F.LocalNumDecls > 0) {
2853  // Introduce the global -> local mapping for declarations within this
2854  // module.
2855  GlobalDeclMap.insert(
2856  std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2857 
2858  // Introduce the local -> global mapping for declarations within this
2859  // module.
2861  std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2862 
2863  // Introduce the global -> local mapping for declarations within this
2864  // module.
2865  F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2866 
2867  DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2868  }
2869  break;
2870  }
2871 
2872  case TU_UPDATE_LEXICAL: {
2873  DeclContext *TU = ContextObj->getTranslationUnitDecl();
2874  LexicalContents Contents(
2875  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2876  Blob.data()),
2877  static_cast<unsigned int>(Blob.size() / 4));
2878  TULexicalDecls.push_back(std::make_pair(&F, Contents));
2879  TU->setHasExternalLexicalStorage(true);
2880  break;
2881  }
2882 
2883  case UPDATE_VISIBLE: {
2884  unsigned Idx = 0;
2885  serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2886  auto *Data = (const unsigned char*)Blob.data();
2887  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2888  // If we've already loaded the decl, perform the updates when we finish
2889  // loading this block.
2890  if (Decl *D = GetExistingDecl(ID))
2891  PendingUpdateRecords.push_back(
2892  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2893  break;
2894  }
2895 
2896  case IDENTIFIER_TABLE:
2897  F.IdentifierTableData = Blob.data();
2898  if (Record[0]) {
2900  (const unsigned char *)F.IdentifierTableData + Record[0],
2901  (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2902  (const unsigned char *)F.IdentifierTableData,
2903  ASTIdentifierLookupTrait(*this, F));
2904 
2905  PP.getIdentifierTable().setExternalIdentifierLookup(this);
2906  }
2907  break;
2908 
2909  case IDENTIFIER_OFFSET: {
2910  if (F.LocalNumIdentifiers != 0) {
2911  Error("duplicate IDENTIFIER_OFFSET record in AST file");
2912  return Failure;
2913  }
2914  F.IdentifierOffsets = (const uint32_t *)Blob.data();
2915  F.LocalNumIdentifiers = Record[0];
2916  unsigned LocalBaseIdentifierID = Record[1];
2917  F.BaseIdentifierID = getTotalNumIdentifiers();
2918 
2919  if (F.LocalNumIdentifiers > 0) {
2920  // Introduce the global -> local mapping for identifiers within this
2921  // module.
2922  GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2923  &F));
2924 
2925  // Introduce the local -> global mapping for identifiers within this
2926  // module.
2928  std::make_pair(LocalBaseIdentifierID,
2929  F.BaseIdentifierID - LocalBaseIdentifierID));
2930 
2931  IdentifiersLoaded.resize(IdentifiersLoaded.size()
2932  + F.LocalNumIdentifiers);
2933  }
2934  break;
2935  }
2936 
2938  F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2939  break;
2940 
2942  // FIXME: Skip reading this record if our ASTConsumer doesn't care
2943  // about "interesting" decls (for instance, if we're building a module).
2944  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2945  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2946  break;
2947 
2948  case MODULAR_CODEGEN_DECLS:
2949  // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2950  // them (ie: if we're not codegenerating this module).
2951  if (F.Kind == MK_MainFile)
2952  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2953  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2954  break;
2955 
2956  case SPECIAL_TYPES:
2957  if (SpecialTypes.empty()) {
2958  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2959  SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2960  break;
2961  }
2962 
2963  if (SpecialTypes.size() != Record.size()) {
2964  Error("invalid special-types record");
2965  return Failure;
2966  }
2967 
2968  for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2969  serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2970  if (!SpecialTypes[I])
2971  SpecialTypes[I] = ID;
2972  // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2973  // merge step?
2974  }
2975  break;
2976 
2977  case STATISTICS:
2978  TotalNumStatements += Record[0];
2979  TotalNumMacros += Record[1];
2980  TotalLexicalDeclContexts += Record[2];
2981  TotalVisibleDeclContexts += Record[3];
2982  break;
2983 
2985  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2986  UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2987  break;
2988 
2989  case DELEGATING_CTORS:
2990  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2991  DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2992  break;
2993 
2995  if (Record.size() % 4 != 0) {
2996  Error("invalid weak identifiers record");
2997  return Failure;
2998  }
2999 
3000  // FIXME: Ignore weak undeclared identifiers from non-original PCH
3001  // files. This isn't the way to do it :)
3002  WeakUndeclaredIdentifiers.clear();
3003 
3004  // Translate the weak, undeclared identifiers into global IDs.
3005  for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3006  WeakUndeclaredIdentifiers.push_back(
3007  getGlobalIdentifierID(F, Record[I++]));
3008  WeakUndeclaredIdentifiers.push_back(
3009  getGlobalIdentifierID(F, Record[I++]));
3010  WeakUndeclaredIdentifiers.push_back(
3011  ReadSourceLocation(F, Record, I).getRawEncoding());
3012  WeakUndeclaredIdentifiers.push_back(Record[I++]);
3013  }
3014  break;
3015 
3016  case SELECTOR_OFFSETS: {
3017  F.SelectorOffsets = (const uint32_t *)Blob.data();
3018  F.LocalNumSelectors = Record[0];
3019  unsigned LocalBaseSelectorID = Record[1];
3020  F.BaseSelectorID = getTotalNumSelectors();
3021 
3022  if (F.LocalNumSelectors > 0) {
3023  // Introduce the global -> local mapping for selectors within this
3024  // module.
3025  GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3026 
3027  // Introduce the local -> global mapping for selectors within this
3028  // module.
3030  std::make_pair(LocalBaseSelectorID,
3031  F.BaseSelectorID - LocalBaseSelectorID));
3032 
3033  SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3034  }
3035  break;
3036  }
3037 
3038  case METHOD_POOL:
3039  F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3040  if (Record[0])
3043  F.SelectorLookupTableData + Record[0],
3045  ASTSelectorLookupTrait(*this, F));
3046  TotalNumMethodPoolEntries += Record[1];
3047  break;
3048 
3050  if (!Record.empty()) {
3051  for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3052  ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3053  Record[Idx++]));
3054  ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3055  getRawEncoding());
3056  }
3057  }
3058  break;
3059 
3060  case PP_CONDITIONAL_STACK:
3061  if (!Record.empty()) {
3062  unsigned Idx = 0, End = Record.size() - 1;
3063  bool ReachedEOFWhileSkipping = Record[Idx++];
3065  if (ReachedEOFWhileSkipping) {
3066  SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3067  SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3068  bool FoundNonSkipPortion = Record[Idx++];
3069  bool FoundElse = Record[Idx++];
3070  SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3071  SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3072  FoundElse, ElseLoc);
3073  }
3074  SmallVector<PPConditionalInfo, 4> ConditionalStack;
3075  while (Idx < End) {
3076  auto Loc = ReadSourceLocation(F, Record, Idx);
3077  bool WasSkipping = Record[Idx++];
3078  bool FoundNonSkip = Record[Idx++];
3079  bool FoundElse = Record[Idx++];
3080  ConditionalStack.push_back(
3081  {Loc, WasSkipping, FoundNonSkip, FoundElse});
3082  }
3083  PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3084  }
3085  break;
3086 
3087  case PP_COUNTER_VALUE:
3088  if (!Record.empty() && Listener)
3089  Listener->ReadCounter(F, Record[0]);
3090  break;
3091 
3092  case FILE_SORTED_DECLS:
3093  F.FileSortedDecls = (const DeclID *)Blob.data();
3094  F.NumFileSortedDecls = Record[0];
3095  break;
3096 
3097  case SOURCE_LOCATION_OFFSETS: {
3098  F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3099  F.LocalNumSLocEntries = Record[0];
3100  unsigned SLocSpaceSize = Record[1];
3101  std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3102  SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3103  SLocSpaceSize);
3104  if (!F.SLocEntryBaseID) {
3105  Error("ran out of source locations");
3106  break;
3107  }
3108  // Make our entry in the range map. BaseID is negative and growing, so
3109  // we invert it. Because we invert it, though, we need the other end of
3110  // the range.
3111  unsigned RangeStart =
3112  unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3113  GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3115 
3116  // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3117  assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3118  GlobalSLocOffsetMap.insert(
3119  std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3120  - SLocSpaceSize,&F));
3121 
3122  // Initialize the remapping table.
3123  // Invalid stays invalid.
3124  F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3125  // This module. Base was 2 when being compiled.
3126  F.SLocRemap.insertOrReplace(std::make_pair(2U,
3127  static_cast<int>(F.SLocEntryBaseOffset - 2)));
3128 
3129  TotalNumSLocEntries += F.LocalNumSLocEntries;
3130  break;
3131  }
3132 
3133  case MODULE_OFFSET_MAP:
3134  F.ModuleOffsetMap = Blob;
3135  break;
3136 
3138  if (ParseLineTable(F, Record))
3139  return Failure;
3140  break;
3141 
3142  case SOURCE_LOCATION_PRELOADS: {
3143  // Need to transform from the local view (1-based IDs) to the global view,
3144  // which is based off F.SLocEntryBaseID.
3145  if (!F.PreloadSLocEntries.empty()) {
3146  Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3147  return Failure;
3148  }
3149 
3150  F.PreloadSLocEntries.swap(Record);
3151  break;
3152  }
3153 
3154  case EXT_VECTOR_DECLS:
3155  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3156  ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3157  break;
3158 
3159  case VTABLE_USES:
3160  if (Record.size() % 3 != 0) {
3161  Error("Invalid VTABLE_USES record");
3162  return Failure;
3163  }
3164 
3165  // Later tables overwrite earlier ones.
3166  // FIXME: Modules will have some trouble with this. This is clearly not
3167  // the right way to do this.
3168  VTableUses.clear();
3169 
3170  for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3171  VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3172  VTableUses.push_back(
3173  ReadSourceLocation(F, Record, Idx).getRawEncoding());
3174  VTableUses.push_back(Record[Idx++]);
3175  }
3176  break;
3177 
3179  if (PendingInstantiations.size() % 2 != 0) {
3180  Error("Invalid existing PendingInstantiations");
3181  return Failure;
3182  }
3183 
3184  if (Record.size() % 2 != 0) {
3185  Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3186  return Failure;
3187  }
3188 
3189  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3190  PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3191  PendingInstantiations.push_back(
3192  ReadSourceLocation(F, Record, I).getRawEncoding());
3193  }
3194  break;
3195 
3196  case SEMA_DECL_REFS:
3197  if (Record.size() != 3) {
3198  Error("Invalid SEMA_DECL_REFS block");
3199  return Failure;
3200  }
3201  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3202  SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3203  break;
3204 
3205  case PPD_ENTITIES_OFFSETS: {
3206  F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3207  assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3208  F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3209 
3210  unsigned LocalBasePreprocessedEntityID = Record[0];
3211 
3212  unsigned StartingID;
3213  if (!PP.getPreprocessingRecord())
3214  PP.createPreprocessingRecord();
3215  if (!PP.getPreprocessingRecord()->getExternalSource())
3216  PP.getPreprocessingRecord()->SetExternalSource(*this);
3217  StartingID
3218  = PP.getPreprocessingRecord()
3219  ->allocateLoadedEntities(F.NumPreprocessedEntities);
3220  F.BasePreprocessedEntityID = StartingID;
3221 
3222  if (F.NumPreprocessedEntities > 0) {
3223  // Introduce the global -> local mapping for preprocessed entities in
3224  // this module.
3225  GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3226 
3227  // Introduce the local -> global mapping for preprocessed entities in
3228  // this module.
3230  std::make_pair(LocalBasePreprocessedEntityID,
3231  F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3232  }
3233 
3234  break;
3235  }
3236 
3237  case PPD_SKIPPED_RANGES: {
3238  F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3239  assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3240  F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3241 
3242  if (!PP.getPreprocessingRecord())
3243  PP.createPreprocessingRecord();
3244  if (!PP.getPreprocessingRecord()->getExternalSource())
3245  PP.getPreprocessingRecord()->SetExternalSource(*this);
3246  F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3247  ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3248 
3249  if (F.NumPreprocessedSkippedRanges > 0)
3250  GlobalSkippedRangeMap.insert(
3251  std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3252  break;
3253  }
3254 
3255  case DECL_UPDATE_OFFSETS:
3256  if (Record.size() % 2 != 0) {
3257  Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3258  return Failure;
3259  }
3260  for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3261  GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3262  DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3263 
3264  // If we've already loaded the decl, perform the updates when we finish
3265  // loading this block.
3266  if (Decl *D = GetExistingDecl(ID))
3267  PendingUpdateRecords.push_back(
3268  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3269  }
3270  break;
3271 
3272  case OBJC_CATEGORIES_MAP:
3273  if (F.LocalNumObjCCategoriesInMap != 0) {
3274  Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3275  return Failure;
3276  }
3277 
3278  F.LocalNumObjCCategoriesInMap = Record[0];
3279  F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3280  break;
3281 
3282  case OBJC_CATEGORIES:
3283  F.ObjCCategories.swap(Record);
3284  break;
3285 
3287  // Later tables overwrite earlier ones.
3288  // FIXME: Modules will have trouble with this.
3289  CUDASpecialDeclRefs.clear();
3290  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3291  CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3292  break;
3293 
3294  case HEADER_SEARCH_TABLE:
3295  F.HeaderFileInfoTableData = Blob.data();
3296  F.LocalNumHeaderFileInfos = Record[1];
3297  if (Record[0]) {
3300  (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3301  (const unsigned char *)F.HeaderFileInfoTableData,
3302  HeaderFileInfoTrait(*this, F,
3303  &PP.getHeaderSearchInfo(),
3304  Blob.data() + Record[2]));
3305 
3306  PP.getHeaderSearchInfo().SetExternalSource(this);
3307  if (!PP.getHeaderSearchInfo().getExternalLookup())
3308  PP.getHeaderSearchInfo().SetExternalLookup(this);
3309  }
3310  break;
3311 
3312  case FP_PRAGMA_OPTIONS:
3313  // Later tables overwrite earlier ones.
3314  FPPragmaOptions.swap(Record);
3315  break;
3316 
3317  case OPENCL_EXTENSIONS:
3318  for (unsigned I = 0, E = Record.size(); I != E; ) {
3319  auto Name = ReadString(Record, I);
3320  auto &Opt = OpenCLExtensions.OptMap[Name];
3321  Opt.Supported = Record[I++] != 0;
3322  Opt.Enabled = Record[I++] != 0;
3323  Opt.Avail = Record[I++];
3324  Opt.Core = Record[I++];
3325  }
3326  break;
3327 
3329  for (unsigned I = 0, E = Record.size(); I != E;) {
3330  auto TypeID = static_cast<::TypeID>(Record[I++]);
3331  auto *Type = GetType(TypeID).getTypePtr();
3332  auto NumExt = static_cast<unsigned>(Record[I++]);
3333  for (unsigned II = 0; II != NumExt; ++II) {
3334  auto Ext = ReadString(Record, I);
3335  OpenCLTypeExtMap[Type].insert(Ext);
3336  }
3337  }
3338  break;
3339 
3341  for (unsigned I = 0, E = Record.size(); I != E;) {
3342  auto DeclID = static_cast<::DeclID>(Record[I++]);
3343  auto *Decl = GetDecl(DeclID);
3344  auto NumExt = static_cast<unsigned>(Record[I++]);
3345  for (unsigned II = 0; II != NumExt; ++II) {
3346  auto Ext = ReadString(Record, I);
3347  OpenCLDeclExtMap[Decl].insert(Ext);
3348  }
3349  }
3350  break;
3351 
3352  case TENTATIVE_DEFINITIONS:
3353  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3354  TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3355  break;
3356 
3357  case KNOWN_NAMESPACES:
3358  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3359  KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3360  break;
3361 
3362  case UNDEFINED_BUT_USED:
3363  if (UndefinedButUsed.size() % 2 != 0) {
3364  Error("Invalid existing UndefinedButUsed");
3365  return Failure;
3366  }
3367 
3368  if (Record.size() % 2 != 0) {
3369  Error("invalid undefined-but-used record");
3370  return Failure;
3371  }
3372  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3373  UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3374  UndefinedButUsed.push_back(
3375  ReadSourceLocation(F, Record, I).getRawEncoding());
3376  }
3377  break;
3378 
3380  for (unsigned I = 0, N = Record.size(); I != N;) {
3381  DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3382  const uint64_t Count = Record[I++];
3383  DelayedDeleteExprs.push_back(Count);
3384  for (uint64_t C = 0; C < Count; ++C) {
3385  DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3386  bool IsArrayForm = Record[I++] == 1;
3387  DelayedDeleteExprs.push_back(IsArrayForm);
3388  }
3389  }
3390  break;
3391 
3392  case IMPORTED_MODULES:
3393  if (!F.isModule()) {
3394  // If we aren't loading a module (which has its own exports), make
3395  // all of the imported modules visible.
3396  // FIXME: Deal with macros-only imports.
3397  for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3398  unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3399  SourceLocation Loc = ReadSourceLocation(F, Record, I);
3400  if (GlobalID) {
3401  ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3402  if (DeserializationListener)
3403  DeserializationListener->ModuleImportRead(GlobalID, Loc);
3404  }
3405  }
3406  }
3407  break;
3408 
3409  case MACRO_OFFSET: {
3410  if (F.LocalNumMacros != 0) {
3411  Error("duplicate MACRO_OFFSET record in AST file");
3412  return Failure;
3413  }
3414  F.MacroOffsets = (const uint32_t *)Blob.data();
3415  F.LocalNumMacros = Record[0];
3416  unsigned LocalBaseMacroID = Record[1];
3417  F.BaseMacroID = getTotalNumMacros();
3418 
3419  if (F.LocalNumMacros > 0) {
3420  // Introduce the global -> local mapping for macros within this module.
3421  GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3422 
3423  // Introduce the local -> global mapping for macros within this module.
3425  std::make_pair(LocalBaseMacroID,
3426  F.BaseMacroID - LocalBaseMacroID));
3427 
3428  MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3429  }
3430  break;
3431  }
3432 
3433  case LATE_PARSED_TEMPLATE:
3434  LateParsedTemplates.append(Record.begin(), Record.end());
3435  break;
3436 
3438  if (Record.size() != 1) {
3439  Error("invalid pragma optimize record");
3440  return Failure;
3441  }
3442  OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3443  break;
3444 
3446  if (Record.size() != 1) {
3447  Error("invalid pragma ms_struct record");
3448  return Failure;
3449  }
3450  PragmaMSStructState = Record[0];
3451  break;
3452 
3454  if (Record.size() != 2) {
3455  Error("invalid pragma ms_struct record");
3456  return Failure;
3457  }
3458  PragmaMSPointersToMembersState = Record[0];
3459  PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3460  break;
3461 
3463  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3464  UnusedLocalTypedefNameCandidates.push_back(
3465  getGlobalDeclID(F, Record[I]));
3466  break;
3467 
3469  if (Record.size() != 1) {
3470  Error("invalid cuda pragma options record");
3471  return Failure;
3472  }
3473  ForceCUDAHostDeviceDepth = Record[0];
3474  break;
3475 
3476  case PACK_PRAGMA_OPTIONS: {
3477  if (Record.size() < 3) {
3478  Error("invalid pragma pack record");
3479  return Failure;
3480  }
3481  PragmaPackCurrentValue = Record[0];
3482  PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3483  unsigned NumStackEntries = Record[2];
3484  unsigned Idx = 3;
3485  // Reset the stack when importing a new module.
3486  PragmaPackStack.clear();
3487  for (unsigned I = 0; I < NumStackEntries; ++I) {
3488  PragmaPackStackEntry Entry;
3489  Entry.Value = Record[Idx++];
3490  Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3491  Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3492  PragmaPackStrings.push_back(ReadString(Record, Idx));
3493  Entry.SlotLabel = PragmaPackStrings.back();
3494  PragmaPackStack.push_back(Entry);
3495  }
3496  break;
3497  }
3498  }
3499  }
3500 }
3501 
3502 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3503  assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3504 
3505  // Additional remapping information.
3506  const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3507  const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3508  F.ModuleOffsetMap = StringRef();
3509 
3510  // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3511  if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3512  F.SLocRemap.insert(std::make_pair(0U, 0));
3513  F.SLocRemap.insert(std::make_pair(2U, 1));
3514  }
3515 
3516  // Continuous range maps we may be updating in our module.
3517  using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3518  RemapBuilder SLocRemap(F.SLocRemap);
3519  RemapBuilder IdentifierRemap(F.IdentifierRemap);
3520  RemapBuilder MacroRemap(F.MacroRemap);
3521  RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3522  RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3523  RemapBuilder SelectorRemap(F.SelectorRemap);
3524  RemapBuilder DeclRemap(F.DeclRemap);
3525  RemapBuilder TypeRemap(F.TypeRemap);
3526 
3527  while (Data < DataEnd) {
3528  // FIXME: Looking up dependency modules by filename is horrible. Let's
3529  // start fixing this with prebuilt and explicit modules and see how it
3530  // goes...
3531  using namespace llvm::support;
3532  ModuleKind Kind = static_cast<ModuleKind>(
3533  endian::readNext<uint8_t, little, unaligned>(Data));
3534  uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3535  StringRef Name = StringRef((const char*)Data, Len);
3536  Data += Len;
3537  ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3538  ? ModuleMgr.lookupByModuleName(Name)
3539  : ModuleMgr.lookupByFileName(Name));
3540  if (!OM) {
3541  std::string Msg =
3542  "SourceLocation remap refers to unknown module, cannot find ";
3543  Msg.append(Name);
3544  Error(Msg);
3545  return;
3546  }
3547 
3548  uint32_t SLocOffset =
3549  endian::readNext<uint32_t, little, unaligned>(Data);
3550  uint32_t IdentifierIDOffset =
3551  endian::readNext<uint32_t, little, unaligned>(Data);
3552  uint32_t MacroIDOffset =
3553  endian::readNext<uint32_t, little, unaligned>(Data);
3554  uint32_t PreprocessedEntityIDOffset =
3555  endian::readNext<uint32_t, little, unaligned>(Data);
3556  uint32_t SubmoduleIDOffset =
3557  endian::readNext<uint32_t, little, unaligned>(Data);
3558  uint32_t SelectorIDOffset =
3559  endian::readNext<uint32_t, little, unaligned>(Data);
3560  uint32_t DeclIDOffset =
3561  endian::readNext<uint32_t, little, unaligned>(Data);
3562  uint32_t TypeIndexOffset =
3563  endian::readNext<uint32_t, little, unaligned>(Data);
3564 
3565  uint32_t None = std::numeric_limits<uint32_t>::max();
3566 
3567  auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3568  RemapBuilder &Remap) {
3569  if (Offset != None)
3570  Remap.insert(std::make_pair(Offset,
3571  static_cast<int>(BaseOffset - Offset)));
3572  };
3573  mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3574  mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3575  mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3576  mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3577  PreprocessedEntityRemap);
3578  mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3579  mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3580  mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3581  mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3582 
3583  // Global -> local mappings.
3584  F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3585  }
3586 }
3587 
3589 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3590  const ModuleFile *ImportedBy,
3591  unsigned ClientLoadCapabilities) {
3592  unsigned Idx = 0;
3593  F.ModuleMapPath = ReadPath(F, Record, Idx);
3594 
3595  // Try to resolve ModuleName in the current header search context and
3596  // verify that it is found in the same module map file as we saved. If the
3597  // top-level AST file is a main file, skip this check because there is no
3598  // usable header search context.
3599  assert(!F.ModuleName.empty() &&
3600  "MODULE_NAME should come before MODULE_MAP_FILE");
3601  if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3602  // An implicitly-loaded module file should have its module listed in some
3603  // module map file that we've already loaded.
3604  Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3605  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3606  const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3607  // Don't emit module relocation error if we have -fno-validate-pch
3608  if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3609  assert(ImportedBy && "top-level import should be verified");
3610  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3611  if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3612  // This module was defined by an imported (explicit) module.
3613  Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3614  << ASTFE->getName();
3615  } else {
3616  // This module was built with a different module map.
3617  Diag(diag::err_imported_module_not_found)
3618  << F.ModuleName << F.FileName << ImportedBy->FileName
3619  << F.ModuleMapPath;
3620  // In case it was imported by a PCH, there's a chance the user is
3621  // just missing to include the search path to the directory containing
3622  // the modulemap.
3623  if (ImportedBy->Kind == MK_PCH)
3624  Diag(diag::note_imported_by_pch_module_not_found)
3625  << llvm::sys::path::parent_path(F.ModuleMapPath);
3626  }
3627  }
3628  return OutOfDate;
3629  }
3630 
3631  assert(M->Name == F.ModuleName && "found module with different name");
3632 
3633  // Check the primary module map file.
3634  const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3635  if (StoredModMap == nullptr || StoredModMap != ModMap) {
3636  assert(ModMap && "found module is missing module map file");
3637  assert(ImportedBy && "top-level import should be verified");
3638  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3639  Diag(diag::err_imported_module_modmap_changed)
3640  << F.ModuleName << ImportedBy->FileName
3641  << ModMap->getName() << F.ModuleMapPath;
3642  return OutOfDate;
3643  }
3644 
3645  llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3646  for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3647  // FIXME: we should use input files rather than storing names.
3648  std::string Filename = ReadPath(F, Record, Idx);
3649  const FileEntry *F =
3650  FileMgr.getFile(Filename, false, false);
3651  if (F == nullptr) {
3652  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3653  Error("could not find file '" + Filename +"' referenced by AST file");
3654  return OutOfDate;
3655  }
3656  AdditionalStoredMaps.insert(F);
3657  }
3658 
3659  // Check any additional module map files (e.g. module.private.modulemap)
3660  // that are not in the pcm.
3661  if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3662  for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3663  // Remove files that match
3664  // Note: SmallPtrSet::erase is really remove
3665  if (!AdditionalStoredMaps.erase(ModMap)) {
3666  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3667  Diag(diag::err_module_different_modmap)
3668  << F.ModuleName << /*new*/0 << ModMap->getName();
3669  return OutOfDate;
3670  }
3671  }
3672  }
3673 
3674  // Check any additional module map files that are in the pcm, but not
3675  // found in header search. Cases that match are already removed.
3676  for (const FileEntry *ModMap : AdditionalStoredMaps) {
3677  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3678  Diag(diag::err_module_different_modmap)
3679  << F.ModuleName << /*not new*/1 << ModMap->getName();
3680  return OutOfDate;
3681  }
3682  }
3683 
3684  if (Listener)
3685  Listener->ReadModuleMapFile(F.ModuleMapPath);
3686  return Success;
3687 }
3688 
3689 /// Move the given method to the back of the global list of methods.
3691  // Find the entry for this selector in the method pool.
3692  Sema::GlobalMethodPool::iterator Known
3693  = S.MethodPool.find(Method->getSelector());
3694  if (Known == S.MethodPool.end())
3695  return;
3696 
3697  // Retrieve the appropriate method list.
3698  ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3699  : Known->second.second;
3700  bool Found = false;
3701  for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3702  if (!Found) {
3703  if (List->getMethod() == Method) {
3704  Found = true;
3705  } else {
3706  // Keep searching.
3707  continue;
3708  }
3709  }
3710 
3711  if (List->getNext())
3712  List->setMethod(List->getNext()->getMethod());
3713  else
3714  List->setMethod(Method);
3715  }
3716 }
3717 
3718 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3719  assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3720  for (Decl *D : Names) {
3721  bool wasHidden = D->isHidden();
3722  D->setVisibleDespiteOwningModule();
3723 
3724  if (wasHidden && SemaObj) {
3725  if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3726  moveMethodToBackOfGlobalList(*SemaObj, Method);
3727  }
3728  }
3729  }
3730 }
3731 
3733  Module::NameVisibilityKind NameVisibility,
3734  SourceLocation ImportLoc) {
3735  llvm::SmallPtrSet<Module *, 4> Visited;
3737  Stack.push_back(Mod);
3738  while (!Stack.empty()) {
3739  Mod = Stack.pop_back_val();
3740 
3741  if (NameVisibility <= Mod->NameVisibility) {
3742  // This module already has this level of visibility (or greater), so
3743  // there is nothing more to do.
3744  continue;
3745  }
3746 
3747  if (!Mod->isAvailable()) {
3748  // Modules that aren't available cannot be made visible.
3749  continue;
3750  }
3751 
3752  // Update the module's name visibility.
3753  Mod->NameVisibility = NameVisibility;
3754 
3755  // If we've already deserialized any names from this module,
3756  // mark them as visible.
3757  HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3758  if (Hidden != HiddenNamesMap.end()) {
3759  auto HiddenNames = std::move(*Hidden);
3760  HiddenNamesMap.erase(Hidden);
3761  makeNamesVisible(HiddenNames.second, HiddenNames.first);
3762  assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3763  "making names visible added hidden names");
3764  }
3765 
3766  // Push any exported modules onto the stack to be marked as visible.
3767  SmallVector<Module *, 16> Exports;
3768  Mod->getExportedModules(Exports);
3770  I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3771  Module *Exported = *I;
3772  if (Visited.insert(Exported).second)
3773  Stack.push_back(Exported);
3774  }
3775  }
3776 }
3777 
3778 /// We've merged the definition \p MergedDef into the existing definition
3779 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3780 /// visible.
3782  NamedDecl *MergedDef) {
3783  // FIXME: This doesn't correctly handle the case where MergedDef is visible
3784  // in modules other than its owning module. We should instead give the
3785  // ASTContext a list of merged definitions for Def.
3786  if (Def->isHidden()) {
3787  // If MergedDef is visible or becomes visible, make the definition visible.
3788  if (!MergedDef->isHidden())
3790  else if (getContext().getLangOpts().ModulesLocalVisibility) {
3791  getContext().mergeDefinitionIntoModule(
3792  Def, MergedDef->getImportedOwningModule(),
3793  /*NotifyListeners*/ false);
3794  PendingMergedDefinitionsToDeduplicate.insert(Def);
3795  } else {
3796  auto SubmoduleID = MergedDef->getOwningModuleID();
3797  assert(SubmoduleID && "hidden definition in no module");
3798  HiddenNamesMap[getSubmodule(SubmoduleID)].push_back(Def);
3799  }
3800  }
3801 }
3802 
3804  if (GlobalIndex)
3805  return false;
3806 
3807  if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3808  !PP.getLangOpts().Modules)
3809  return true;
3810 
3811  // Try to load the global index.
3812  TriedLoadingGlobalIndex = true;
3813  StringRef ModuleCachePath
3814  = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3815  std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3816  = GlobalModuleIndex::readIndex(ModuleCachePath);
3817  if (!Result.first)
3818  return true;
3819 
3820  GlobalIndex.reset(Result.first);
3821  ModuleMgr.setGlobalIndex(GlobalIndex.get());
3822  return false;
3823 }
3824 
3826  return PP.getLangOpts().Modules && UseGlobalIndex &&
3827  !hasGlobalIndex() && TriedLoadingGlobalIndex;
3828 }
3829 
3831  // Overwrite the timestamp file contents so that file's mtime changes.
3832  std::string TimestampFilename = MF.getTimestampFilename();
3833  std::error_code EC;
3834  llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3835  if (EC)
3836  return;
3837  OS << "Timestamp file\n";
3838  OS.close();
3839  OS.clear_error(); // Avoid triggering a fatal error.
3840 }
3841 
3842 /// Given a cursor at the start of an AST file, scan ahead and drop the
3843 /// cursor into the start of the given block ID, returning false on success and
3844 /// true on failure.
3845 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3846  while (true) {
3847  llvm::BitstreamEntry Entry = Cursor.advance();
3848  switch (Entry.Kind) {
3850  case llvm::BitstreamEntry::EndBlock:
3851  return true;
3852 
3853  case llvm::BitstreamEntry::Record:
3854  // Ignore top-level records.
3855  Cursor.skipRecord(Entry.ID);
3856  break;
3857 
3858  case llvm::BitstreamEntry::SubBlock:
3859  if (Entry.ID == BlockID) {
3860  if (Cursor.EnterSubBlock(BlockID))
3861  return true;
3862  // Found it!
3863  return false;
3864  }
3865 
3866  if (Cursor.SkipBlock())
3867  return true;
3868  }
3869  }
3870 }
3871 
3873  ModuleKind Type,
3874  SourceLocation ImportLoc,
3875  unsigned ClientLoadCapabilities,
3878  SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3879 
3880  // Defer any pending actions until we get to the end of reading the AST file.
3881  Deserializing AnASTFile(this);
3882 
3883  // Bump the generation number.
3884  unsigned PreviousGeneration = 0;
3885  if (ContextObj)
3886  PreviousGeneration = incrementGeneration(*ContextObj);
3887 
3888  unsigned NumModules = ModuleMgr.size();
3890  switch (ASTReadResult ReadResult =
3891  ReadASTCore(FileName, Type, ImportLoc,
3892  /*ImportedBy=*/nullptr, Loaded, 0, 0,
3893  ASTFileSignature(), ClientLoadCapabilities)) {
3894  case Failure:
3895  case Missing:
3896  case OutOfDate:
3897  case VersionMismatch:
3898  case ConfigurationMismatch:
3899  case HadErrors: {
3900  llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3901  for (const ImportedModule &IM : Loaded)
3902  LoadedSet.insert(IM.Mod);
3903 
3904  ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3905  PP.getLangOpts().Modules
3906  ? &PP.getHeaderSearchInfo().getModuleMap()
3907  : nullptr);
3908 
3909  // If we find that any modules are unusable, the global index is going
3910  // to be out-of-date. Just remove it.
3911  GlobalIndex.reset();
3912  ModuleMgr.setGlobalIndex(nullptr);
3913  return ReadResult;
3914  }
3915  case Success:
3916  break;
3917  }
3918 
3919  // Here comes stuff that we only do once the entire chain is loaded.
3920 
3921  // Load the AST blocks of all of the modules that we loaded.
3922  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3923  MEnd = Loaded.end();
3924  M != MEnd; ++M) {
3925  ModuleFile &F = *M->Mod;
3926 
3927  // Read the AST block.
3928  if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3929  return Result;
3930 
3931  // Read the extension blocks.
3933  if (ASTReadResult Result = ReadExtensionBlock(F))
3934  return Result;
3935  }
3936 
3937  // Once read, set the ModuleFile bit base offset and update the size in
3938  // bits of all files we've seen.
3939  F.GlobalBitOffset = TotalModulesSizeInBits;
3940  TotalModulesSizeInBits += F.SizeInBits;
3941  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3942 
3943  // Preload SLocEntries.
3944  for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3945  int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3946  // Load it through the SourceManager and don't call ReadSLocEntry()
3947  // directly because the entry may have already been loaded in which case
3948  // calling ReadSLocEntry() directly would trigger an assertion in
3949  // SourceManager.
3950  SourceMgr.getLoadedSLocEntryByID(Index);
3951  }
3952 
3953  // Map the original source file ID into the ID space of the current
3954  // compilation.
3955  if (F.OriginalSourceFileID.isValid()) {
3956  F.OriginalSourceFileID = FileID::get(
3957  F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3958  }
3959 
3960  // Preload all the pending interesting identifiers by marking them out of
3961  // date.
3962  for (auto Offset : F.PreloadIdentifierOffsets) {
3963  const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3965 
3966  ASTIdentifierLookupTrait Trait(*this, F);
3967  auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3968  auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3969  auto &II = PP.getIdentifierTable().getOwn(Key);
3970  II.setOutOfDate(true);
3971 
3972  // Mark this identifier as being from an AST file so that we can track
3973  // whether we need to serialize it.
3974  markIdentifierFromAST(*this, II);
3975 
3976  // Associate the ID with the identifier so that the writer can reuse it.
3977  auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3978  SetIdentifierInfo(ID, &II);
3979  }
3980  }
3981 
3982  // Setup the import locations and notify the module manager that we've
3983  // committed to these module files.
3984  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3985  MEnd = Loaded.end();
3986  M != MEnd; ++M) {
3987  ModuleFile &F = *M->Mod;
3988 
3989  ModuleMgr.moduleFileAccepted(&F);
3990 
3991  // Set the import location.
3992  F.DirectImportLoc = ImportLoc;
3993  // FIXME: We assume that locations from PCH / preamble do not need
3994  // any translation.
3995  if (!M->ImportedBy)
3996  F.ImportLoc = M->ImportLoc;
3997  else
3998  F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3999  }
4000 
4001  if (!PP.getLangOpts().CPlusPlus ||
4002  (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
4003  Type != MK_PrebuiltModule)) {
4004  // Mark all of the identifiers in the identifier table as being out of date,
4005  // so that various accessors know to check the loaded modules when the
4006  // identifier is used.
4007  //
4008  // For C++ modules, we don't need information on many identifiers (just
4009  // those that provide macros or are poisoned), so we mark all of
4010  // the interesting ones via PreloadIdentifierOffsets.
4011  for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4012  IdEnd = PP.getIdentifierTable().end();
4013  Id != IdEnd; ++Id)
4014  Id->second->setOutOfDate(true);
4015  }
4016  // Mark selectors as out of date.
4017  for (auto Sel : SelectorGeneration)
4018  SelectorOutOfDate[Sel.first] = true;
4019 
4020  // Resolve any unresolved module exports.
4021  for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4022  UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4023  SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4024  Module *ResolvedMod = getSubmodule(GlobalID);
4025 
4026  switch (Unresolved.Kind) {
4027  case UnresolvedModuleRef::Conflict:
4028  if (ResolvedMod) {
4029  Module::Conflict Conflict;
4030  Conflict.Other = ResolvedMod;
4031  Conflict.Message = Unresolved.String.str();
4032  Unresolved.Mod->Conflicts.push_back(Conflict);
4033  }
4034  continue;
4035 
4036  case UnresolvedModuleRef::Import:
4037  if (ResolvedMod)
4038  Unresolved.Mod->Imports.insert(ResolvedMod);
4039  continue;
4040 
4041  case UnresolvedModuleRef::Export:
4042  if (ResolvedMod || Unresolved.IsWildcard)
4043  Unresolved.Mod->Exports.push_back(
4044  Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4045  continue;
4046  }
4047  }
4048  UnresolvedModuleRefs.clear();
4049 
4050  if (Imported)
4051  Imported->append(ImportedModules.begin(),
4052  ImportedModules.end());
4053 
4054  // FIXME: How do we load the 'use'd modules? They may not be submodules.
4055  // Might be unnecessary as use declarations are only used to build the
4056  // module itself.
4057 
4058  if (ContextObj)
4059  InitializeContext();
4060 
4061  if (SemaObj)
4062  UpdateSema();
4063 
4064  if (DeserializationListener)
4065  DeserializationListener->ReaderInitialized(this);
4066 
4067  ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4068  if (PrimaryModule.OriginalSourceFileID.isValid()) {
4069  // If this AST file is a precompiled preamble, then set the
4070  // preamble file ID of the source manager to the file source file
4071  // from which the preamble was built.
4072  if (Type == MK_Preamble) {
4073  SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4074  } else if (Type == MK_MainFile) {
4075  SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4076  }
4077  }
4078 
4079  // For any Objective-C class definitions we have already loaded, make sure
4080  // that we load any additional categories.
4081  if (ContextObj) {
4082  for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4083  loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4084  ObjCClassesLoaded[I],
4085  PreviousGeneration);
4086  }
4087  }
4088 
4089  if (PP.getHeaderSearchInfo()
4090  .getHeaderSearchOpts()
4091  .ModulesValidateOncePerBuildSession) {
4092  // Now we are certain that the module and all modules it depends on are
4093  // up to date. Create or update timestamp files for modules that are
4094  // located in the module cache (not for PCH files that could be anywhere
4095  // in the filesystem).
4096  for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4097  ImportedModule &M = Loaded[I];
4098  if (M.Mod->Kind == MK_ImplicitModule) {
4099  updateModuleTimestamp(*M.Mod);
4100  }
4101  }
4102  }
4103 
4104  return Success;
4105 }
4106 
4107 static ASTFileSignature readASTFileSignature(StringRef PCH);
4108 
4109 /// Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4110 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4111  return Stream.canSkipToPos(4) &&
4112  Stream.Read(8) == 'C' &&
4113  Stream.Read(8) == 'P' &&
4114  Stream.Read(8) == 'C' &&
4115  Stream.Read(8) == 'H';
4116 }
4117 
4119  switch (Kind) {
4120  case MK_PCH:
4121  return 0; // PCH
4122  case MK_ImplicitModule:
4123  case MK_ExplicitModule:
4124  case MK_PrebuiltModule:
4125  return 1; // module
4126  case MK_MainFile:
4127  case MK_Preamble:
4128  return 2; // main source file
4129  }
4130  llvm_unreachable("unknown module kind");
4131 }
4132 
4134 ASTReader::ReadASTCore(StringRef FileName,
4135  ModuleKind Type,
4136  SourceLocation ImportLoc,
4137  ModuleFile *ImportedBy,
4139  off_t ExpectedSize, time_t ExpectedModTime,
4140  ASTFileSignature ExpectedSignature,
4141  unsigned ClientLoadCapabilities) {
4142  ModuleFile *M;
4143  std::string ErrorStr;
4145  = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4146  getGeneration(), ExpectedSize, ExpectedModTime,
4147  ExpectedSignature, readASTFileSignature,
4148  M, ErrorStr);
4149 
4150  switch (AddResult) {
4152  return Success;
4153 
4155  // Load module file below.
4156  break;
4157 
4159  // The module file was missing; if the client can handle that, return
4160  // it.
4161  if (ClientLoadCapabilities & ARR_Missing)
4162  return Missing;
4163 
4164  // Otherwise, return an error.
4165  Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4166  << FileName << !ErrorStr.empty()
4167  << ErrorStr;
4168  return Failure;
4169 
4171  // We couldn't load the module file because it is out-of-date. If the
4172  // client can handle out-of-date, return it.
4173  if (ClientLoadCapabilities & ARR_OutOfDate)
4174  return OutOfDate;
4175 
4176  // Otherwise, return an error.
4177  Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4178  << FileName << !ErrorStr.empty()
4179  << ErrorStr;
4180  return Failure;
4181  }
4182 
4183  assert(M && "Missing module file");
4184 
4185  ModuleFile &F = *M;
4186  BitstreamCursor &Stream = F.Stream;
4187  Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4188  F.SizeInBits = F.Buffer->getBufferSize() * 8;
4189 
4190  // Sniff for the signature.
4191  if (!startsWithASTFileMagic(Stream)) {
4192  Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4193  << FileName;
4194  return Failure;
4195  }
4196 
4197  // This is used for compatibility with older PCH formats.
4198  bool HaveReadControlBlock = false;
4199  while (true) {
4200  llvm::BitstreamEntry Entry = Stream.advance();
4201 
4202  switch (Entry.Kind) {
4204  case llvm::BitstreamEntry::Record:
4205  case llvm::BitstreamEntry::EndBlock:
4206  Error("invalid record at top-level of AST file");
4207  return Failure;
4208 
4209  case llvm::BitstreamEntry::SubBlock:
4210  break;
4211  }
4212 
4213  switch (Entry.ID) {
4214  case CONTROL_BLOCK_ID:
4215  HaveReadControlBlock = true;
4216  switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4217  case Success:
4218  // Check that we didn't try to load a non-module AST file as a module.
4219  //
4220  // FIXME: Should we also perform the converse check? Loading a module as
4221  // a PCH file sort of works, but it's a bit wonky.
4222  if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4223  Type == MK_PrebuiltModule) &&
4224  F.ModuleName.empty()) {
4225  auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4226  if (Result != OutOfDate ||
4227  (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4228  Diag(diag::err_module_file_not_module) << FileName;
4229  return Result;
4230  }
4231  break;
4232 
4233  case Failure: return Failure;
4234  case Missing: return Missing;
4235  case OutOfDate: return OutOfDate;
4236  case VersionMismatch: return VersionMismatch;
4237  case ConfigurationMismatch: return ConfigurationMismatch;
4238  case HadErrors: return HadErrors;
4239  }
4240  break;
4241 
4242  case AST_BLOCK_ID:
4243  if (!HaveReadControlBlock) {
4244  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4245  Diag(diag::err_pch_version_too_old);
4246  return VersionMismatch;
4247  }
4248 
4249  // Record that we've loaded this module.
4250  Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4251  return Success;
4252 
4254  // This block is handled using look-ahead during ReadControlBlock. We
4255  // shouldn't get here!
4256  Error("malformed block record in AST file");
4257  return Failure;
4258 
4259  default:
4260  if (Stream.SkipBlock()) {
4261  Error("malformed block record in AST file");
4262  return Failure;
4263  }
4264  break;
4265  }
4266  }
4267 
4268  return Success;
4269 }
4270 
4272 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4273  unsigned ClientLoadCapabilities) {
4274  const HeaderSearchOptions &HSOpts =
4275  PP.getHeaderSearchInfo().getHeaderSearchOpts();
4276  bool AllowCompatibleConfigurationMismatch =
4278 
4279  ASTReadResult Result = readUnhashedControlBlockImpl(
4280  &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4281  Listener.get(),
4282  WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4283 
4284  // If F was directly imported by another module, it's implicitly validated by
4285  // the importing module.
4286  if (DisableValidation || WasImportedBy ||
4287  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4288  return Success;
4289 
4290  if (Result == Failure) {
4291  Error("malformed block record in AST file");
4292  return Failure;
4293  }
4294 
4295  if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4296  // If this module has already been finalized in the PCMCache, we're stuck
4297  // with it; we can only load a single version of each module.
4298  //
4299  // This can happen when a module is imported in two contexts: in one, as a
4300  // user module; in another, as a system module (due to an import from
4301  // another module marked with the [system] flag). It usually indicates a
4302  // bug in the module map: this module should also be marked with [system].
4303  //
4304  // If -Wno-system-headers (the default), and the first import is as a
4305  // system module, then validation will fail during the as-user import,
4306  // since -Werror flags won't have been validated. However, it's reasonable
4307  // to treat this consistently as a system module.
4308  //
4309  // If -Wsystem-headers, the PCM on disk was built with
4310  // -Wno-system-headers, and the first import is as a user module, then
4311  // validation will fail during the as-system import since the PCM on disk
4312  // doesn't guarantee that -Werror was respected. However, the -Werror
4313  // flags were checked during the initial as-user import.
4314  if (PCMCache.isBufferFinal(F.FileName)) {
4315  Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4316  return Success;
4317  }
4318  }
4319 
4320  return Result;
4321 }
4322 
4323 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4324  ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4325  bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4326  bool ValidateDiagnosticOptions) {
4327  // Initialize a stream.
4328  BitstreamCursor Stream(StreamData);
4329 
4330  // Sniff for the signature.
4331  if (!startsWithASTFileMagic(Stream))
4332  return Failure;
4333 
4334  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4336  return Failure;
4337 
4338  // Read all of the records in the options block.
4339  RecordData Record;
4340  ASTReadResult Result = Success;
4341  while (true) {
4342  llvm::BitstreamEntry Entry = Stream.advance();
4343 
4344  switch (Entry.Kind) {
4346  case llvm::BitstreamEntry::SubBlock:
4347  return Failure;
4348 
4349  case llvm::BitstreamEntry::EndBlock:
4350  return Result;
4351 
4352  case llvm::BitstreamEntry::Record:
4353  // The interesting case.
4354  break;
4355  }
4356 
4357  // Read and process a record.
4358  Record.clear();
4359  switch (
4360  (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4361  case SIGNATURE:
4362  if (F)
4363  std::copy(Record.begin(), Record.end(), F->Signature.data());
4364  break;
4365  case DIAGNOSTIC_OPTIONS: {
4366  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4367  if (Listener && ValidateDiagnosticOptions &&
4368  !AllowCompatibleConfigurationMismatch &&
4369  ParseDiagnosticOptions(Record, Complain, *Listener))
4370  Result = OutOfDate; // Don't return early. Read the signature.
4371  break;
4372  }
4373  case DIAG_PRAGMA_MAPPINGS:
4374  if (!F)
4375  break;
4376  if (F->PragmaDiagMappings.empty())
4377  F->PragmaDiagMappings.swap(Record);
4378  else
4379  F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4380  Record.begin(), Record.end());
4381  break;
4382  }
4383  }
4384 }
4385 
4386 /// Parse a record and blob containing module file extension metadata.
4388  const SmallVectorImpl<uint64_t> &Record,
4389  StringRef Blob,
4390  ModuleFileExtensionMetadata &Metadata) {
4391  if (Record.size() < 4) return true;
4392 
4393  Metadata.MajorVersion = Record[0];
4394  Metadata.MinorVersion = Record[1];
4395 
4396  unsigned BlockNameLen = Record[2];
4397  unsigned UserInfoLen = Record[3];
4398 
4399  if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4400 
4401  Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4402  Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4403  Blob.data() + BlockNameLen + UserInfoLen);
4404  return false;
4405 }
4406 
4407 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4408  BitstreamCursor &Stream = F.Stream;
4409 
4410  RecordData Record;
4411  while (true) {
4412  llvm::BitstreamEntry Entry = Stream.advance();
4413  switch (Entry.Kind) {
4414  case llvm::BitstreamEntry::SubBlock:
4415  if (Stream.SkipBlock())
4416  return Failure;
4417 
4418  continue;
4419 
4420  case llvm::BitstreamEntry::EndBlock:
4421  return Success;
4422 
4424  return HadErrors;
4425 
4426  case llvm::BitstreamEntry::Record:
4427  break;
4428  }
4429 
4430  Record.clear();
4431  StringRef Blob;
4432  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4433  switch (RecCode) {
4434  case EXTENSION_METADATA: {
4435  ModuleFileExtensionMetadata Metadata;
4436  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4437  return Failure;
4438 
4439  // Find a module file extension with this block name.
4440  auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4441  if (Known == ModuleFileExtensions.end()) break;
4442 
4443  // Form a reader.
4444  if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4445  F, Stream)) {
4446  F.ExtensionReaders.push_back(std::move(Reader));
4447  }
4448 
4449  break;
4450  }
4451  }
4452  }
4453 
4454  return Success;
4455 }
4456 
4458  assert(ContextObj && "no context to initialize");
4459  ASTContext &Context = *ContextObj;
4460 
4461  // If there's a listener, notify them that we "read" the translation unit.
4462  if (DeserializationListener)
4463  DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4464  Context.getTranslationUnitDecl());
4465 
4466  // FIXME: Find a better way to deal with collisions between these
4467  // built-in types. Right now, we just ignore the problem.
4468 
4469  // Load the special types.
4470  if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4471  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4472  if (!Context.CFConstantStringTypeDecl)
4473  Context.setCFConstantStringType(GetType(String));
4474  }
4475 
4476  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4477  QualType FileType = GetType(File);
4478  if (FileType.isNull()) {
4479  Error("FILE type is NULL");
4480  return;
4481  }
4482 
4483  if (!Context.FILEDecl) {
4484  if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4485  Context.setFILEDecl(Typedef->getDecl());
4486  else {
4487  const TagType *Tag = FileType->getAs<TagType>();
4488  if (!Tag) {
4489  Error("Invalid FILE type in AST file");
4490  return;
4491  }
4492  Context.setFILEDecl(Tag->getDecl());
4493  }
4494  }
4495  }
4496 
4497  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4498  QualType Jmp_bufType = GetType(Jmp_buf);
4499  if (Jmp_bufType.isNull()) {
4500  Error("jmp_buf type is NULL");
4501  return;
4502  }
4503 
4504  if (!Context.jmp_bufDecl) {
4505  if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4506  Context.setjmp_bufDecl(Typedef->getDecl());
4507  else {
4508  const TagType *Tag = Jmp_bufType->getAs<TagType>();
4509  if (!Tag) {
4510  Error("Invalid jmp_buf type in AST file");
4511  return;
4512  }
4513  Context.setjmp_bufDecl(Tag->getDecl());
4514  }
4515  }
4516  }
4517 
4518  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4519  QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4520  if (Sigjmp_bufType.isNull()) {
4521  Error("sigjmp_buf type is NULL");
4522  return;
4523  }
4524 
4525  if (!Context.sigjmp_bufDecl) {
4526  if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4527  Context.setsigjmp_bufDecl(Typedef->getDecl());
4528  else {
4529  const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4530  assert(Tag && "Invalid sigjmp_buf type in AST file");
4531  Context.setsigjmp_bufDecl(Tag->getDecl());
4532  }
4533  }
4534  }
4535 
4536  if (unsigned ObjCIdRedef
4537  = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4538  if (Context.ObjCIdRedefinitionType.isNull())
4539  Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4540  }
4541 
4542  if (unsigned ObjCClassRedef
4543  = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4544  if (Context.ObjCClassRedefinitionType.isNull())
4545  Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4546  }
4547 
4548  if (unsigned ObjCSelRedef
4549  = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4550  if (Context.ObjCSelRedefinitionType.isNull())
4551  Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4552  }
4553 
4554  if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4555  QualType Ucontext_tType = GetType(Ucontext_t);
4556  if (Ucontext_tType.isNull()) {
4557  Error("ucontext_t type is NULL");
4558  return;
4559  }
4560 
4561  if (!Context.ucontext_tDecl) {
4562  if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4563  Context.setucontext_tDecl(Typedef->getDecl());
4564  else {
4565  const TagType *Tag = Ucontext_tType->getAs<TagType>();
4566  assert(Tag && "Invalid ucontext_t type in AST file");
4567  Context.setucontext_tDecl(Tag->getDecl());
4568  }
4569  }
4570  }
4571  }
4572 
4573  ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4574 
4575  // If there were any CUDA special declarations, deserialize them.
4576  if (!CUDASpecialDeclRefs.empty()) {
4577  assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4578  Context.setcudaConfigureCallDecl(
4579  cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4580  }
4581 
4582  // Re-export any modules that were imported by a non-module AST file.
4583  // FIXME: This does not make macro-only imports visible again.
4584  for (auto &Import : ImportedModules) {
4585  if (Module *Imported = getSubmodule(Import.ID)) {
4586  makeModuleVisible(Imported, Module::AllVisible,
4587  /*ImportLoc=*/Import.ImportLoc);
4588  if (Import.ImportLoc.isValid())
4589  PP.makeModuleVisible(Imported, Import.ImportLoc);
4590  // FIXME: should we tell Sema to make the module visible too?
4591  }
4592  }
4593  ImportedModules.clear();
4594 }
4595 
4597  // Nothing to do for now.
4598 }
4599 
4600 /// Reads and return the signature record from \p PCH's control block, or
4601 /// else returns 0.
4603  BitstreamCursor Stream(PCH);
4604  if (!startsWithASTFileMagic(Stream))
4605  return ASTFileSignature();
4606 
4607  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4609  return ASTFileSignature();
4610 
4611  // Scan for SIGNATURE inside the diagnostic options block.
4612  ASTReader::RecordData Record;
4613  while (true) {
4614  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4615  if (Entry.Kind != llvm::BitstreamEntry::Record)
4616  return ASTFileSignature();
4617 
4618  Record.clear();
4619  StringRef Blob;
4620  if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4621  return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4622  (uint32_t)Record[3], (uint32_t)Record[4]}}};
4623  }
4624 }
4625 
4626 /// Retrieve the name of the original source file name
4627 /// directly from the AST file, without actually loading the AST
4628 /// file.
4630  const std::string &ASTFileName, FileManager &FileMgr,
4631  const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4632  // Open the AST file.
4633  auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4634  if (!Buffer) {
4635  Diags.Report(diag::err_fe_unable_to_read_pch_file)
4636  << ASTFileName << Buffer.getError().message();
4637  return std::string();
4638  }
4639 
4640  // Initialize the stream
4641  BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4642 
4643  // Sniff for the signature.
4644  if (!startsWithASTFileMagic(Stream)) {
4645  Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4646  return std::string();
4647  }
4648 
4649  // Scan for the CONTROL_BLOCK_ID block.
4650  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4651  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4652  return std::string();
4653  }
4654 
4655  // Scan for ORIGINAL_FILE inside the control block.
4656  RecordData Record;
4657  while (true) {
4658  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4659  if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4660  return std::string();
4661 
4662  if (Entry.Kind != llvm::BitstreamEntry::Record) {
4663  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4664  return std::string();
4665  }
4666 
4667  Record.clear();
4668  StringRef Blob;
4669  if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4670  return Blob.str();
4671  }
4672 }
4673 
4674 namespace {
4675 
4676  class SimplePCHValidator : public ASTReaderListener {
4677  const LangOptions &ExistingLangOpts;
4678  const TargetOptions &ExistingTargetOpts;
4679  const PreprocessorOptions &ExistingPPOpts;
4680  std::string ExistingModuleCachePath;
4681  FileManager &FileMgr;
4682 
4683  public:
4684  SimplePCHValidator(const LangOptions &ExistingLangOpts,
4685  const TargetOptions &ExistingTargetOpts,
4686  const PreprocessorOptions &ExistingPPOpts,
4687  StringRef ExistingModuleCachePath,
4688  FileManager &FileMgr)
4689  : ExistingLangOpts(ExistingLangOpts),
4690  ExistingTargetOpts(ExistingTargetOpts),
4691  ExistingPPOpts(ExistingPPOpts),
4692  ExistingModuleCachePath(ExistingModuleCachePath),
4693  FileMgr(FileMgr) {}
4694 
4695  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4696  bool AllowCompatibleDifferences) override {
4697  return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4698  AllowCompatibleDifferences);
4699  }
4700 
4701  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4702  bool AllowCompatibleDifferences) override {
4703  return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4704  AllowCompatibleDifferences);
4705  }
4706 
4707  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4708  StringRef SpecificModuleCachePath,
4709  bool Complain) override {
4710  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4711  ExistingModuleCachePath,
4712  nullptr, ExistingLangOpts);
4713  }
4714 
4715  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4716  bool Complain,
4717  std::string &SuggestedPredefines) override {
4718  return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4719  SuggestedPredefines, ExistingLangOpts);
4720  }
4721  };
4722 
4723 } // namespace
4724 
4726  StringRef Filename, FileManager &FileMgr,
4727  const PCHContainerReader &PCHContainerRdr,
4728  bool FindModuleFileExtensions,
4729  ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4730  // Open the AST file.
4731  // FIXME: This allows use of the VFS; we do not allow use of the
4732  // VFS when actually loading a module.
4733  auto Buffer = FileMgr.getBufferForFile(Filename);
4734  if (!Buffer) {
4735  return true;
4736  }
4737 
4738  // Initialize the stream
4739  StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4740  BitstreamCursor Stream(Bytes);
4741 
4742  // Sniff for the signature.
4743  if (!startsWithASTFileMagic(Stream))
4744  return true;
4745 
4746  // Scan for the CONTROL_BLOCK_ID block.
4747  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4748  return true;
4749 
4750  bool NeedsInputFiles = Listener.needsInputFileVisitation();
4751  bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4752  bool NeedsImports = Listener.needsImportVisitation();
4753  BitstreamCursor InputFilesCursor;
4754 
4755  RecordData Record;
4756  std::string ModuleDir;
4757  bool DoneWithControlBlock = false;
4758  while (!DoneWithControlBlock) {
4759  llvm::BitstreamEntry Entry = Stream.advance();
4760 
4761  switch (Entry.Kind) {
4762  case llvm::BitstreamEntry::SubBlock: {
4763  switch (Entry.ID) {
4764  case OPTIONS_BLOCK_ID: {
4765  std::string IgnoredSuggestedPredefines;
4766  if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4767  /*AllowCompatibleConfigurationMismatch*/ false,
4768  Listener, IgnoredSuggestedPredefines) != Success)
4769  return true;
4770  break;
4771  }
4772 
4773  case INPUT_FILES_BLOCK_ID:
4774  InputFilesCursor = Stream;
4775  if (Stream.SkipBlock() ||
4776  (NeedsInputFiles &&
4777  ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4778  return true;
4779  break;
4780 
4781  default:
4782  if (Stream.SkipBlock())
4783  return true;
4784  break;
4785  }
4786 
4787  continue;
4788  }
4789 
4790  case llvm::BitstreamEntry::EndBlock:
4791  DoneWithControlBlock = true;
4792  break;
4793 
4795  return true;
4796 
4797  case llvm::BitstreamEntry::Record:
4798  break;
4799  }
4800 
4801  if (DoneWithControlBlock) break;
4802 
4803  Record.clear();
4804  StringRef Blob;
4805  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4806  switch ((ControlRecordTypes)RecCode) {
4807  case METADATA:
4808  if (Record[0] != VERSION_MAJOR)
4809  return true;
4810  if (Listener.ReadFullVersionInformation(Blob))
4811  return true;
4812  break;
4813  case MODULE_NAME:
4814  Listener.ReadModuleName(Blob);
4815  break;
4816  case MODULE_DIRECTORY:
4817  ModuleDir = Blob;
4818  break;
4819  case MODULE_MAP_FILE: {
4820  unsigned Idx = 0;
4821  auto Path = ReadString(Record, Idx);
4822  ResolveImportedPath(Path, ModuleDir);
4823  Listener.ReadModuleMapFile(Path);
4824  break;
4825  }
4826  case INPUT_FILE_OFFSETS: {
4827  if (!NeedsInputFiles)
4828  break;
4829 
4830  unsigned NumInputFiles = Record[0];
4831  unsigned NumUserFiles = Record[1];
4832  const llvm::support::unaligned_uint64_t *InputFileOffs =
4833  (const llvm::support::unaligned_uint64_t *)Blob.data();
4834  for (unsigned I = 0; I != NumInputFiles; ++I) {
4835  // Go find this input file.
4836  bool isSystemFile = I >= NumUserFiles;
4837 
4838  if (isSystemFile && !NeedsSystemInputFiles)
4839  break; // the rest are system input files
4840 
4841  BitstreamCursor &Cursor = InputFilesCursor;
4842  SavedStreamPosition SavedPosition(Cursor);
4843  Cursor.JumpToBit(InputFileOffs[I]);
4844 
4845  unsigned Code = Cursor.ReadCode();
4846  RecordData Record;
4847  StringRef Blob;
4848  bool shouldContinue = false;
4849  switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4850  case INPUT_FILE:
4851  bool Overridden = static_cast<bool>(Record[3]);
4852  std::string Filename = Blob;
4853  ResolveImportedPath(Filename, ModuleDir);
4854  shouldContinue = Listener.visitInputFile(
4855  Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4856  break;
4857  }
4858  if (!shouldContinue)
4859  break;
4860  }
4861  break;
4862  }
4863 
4864  case IMPORTS: {
4865  if (!NeedsImports)
4866  break;
4867 
4868  unsigned Idx = 0, N = Record.size();
4869  while (Idx < N) {
4870  // Read information about the AST file.
4871  Idx += 5; // ImportLoc, Size, ModTime, Signature
4872  SkipString(Record, Idx); // Module name; FIXME: pass to listener?
4873  std::string Filename = ReadString(Record, Idx);
4874  ResolveImportedPath(Filename, ModuleDir);
4875  Listener.visitImport(Filename);
4876  }
4877  break;
4878  }
4879 
4880  default:
4881  // No other validation to perform.
4882  break;
4883  }
4884  }
4885 
4886  // Look for module file extension blocks, if requested.
4887  if (FindModuleFileExtensions) {
4888  BitstreamCursor SavedStream = Stream;
4889  while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4890  bool DoneWithExtensionBlock = false;
4891  while (!DoneWithExtensionBlock) {
4892  llvm::BitstreamEntry Entry = Stream.advance();
4893 
4894  switch (Entry.Kind) {
4895  case llvm::BitstreamEntry::SubBlock:
4896  if (Stream.SkipBlock())
4897  return true;
4898 
4899  continue;
4900 
4901  case llvm::BitstreamEntry::EndBlock:
4902  DoneWithExtensionBlock = true;
4903  continue;
4904 
4906  return true;
4907 
4908  case llvm::BitstreamEntry::Record:
4909  break;
4910  }
4911 
4912  Record.clear();
4913  StringRef Blob;
4914  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4915  switch (RecCode) {
4916  case EXTENSION_METADATA: {
4917  ModuleFileExtensionMetadata Metadata;
4918  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4919  return true;
4920 
4921  Listener.readModuleFileExtension(Metadata);
4922  break;
4923  }
4924  }
4925  }
4926  }
4927  Stream = SavedStream;
4928  }
4929 
4930  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4931  if (readUnhashedControlBlockImpl(
4932  nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4933  /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4934  ValidateDiagnosticOptions) != Success)
4935  return true;
4936 
4937  return false;
4938 }
4939 
4941  const PCHContainerReader &PCHContainerRdr,
4942  const LangOptions &LangOpts,
4943  const TargetOptions &TargetOpts,
4944  const PreprocessorOptions &PPOpts,
4945  StringRef ExistingModuleCachePath) {
4946  SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4947  ExistingModuleCachePath, FileMgr);
4948  return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4949  /*FindModuleFileExtensions=*/false,
4950  validator,
4951  /*ValidateDiagnosticOptions=*/true);
4952 }
4953 
4955 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4956  // Enter the submodule block.
4957  if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4958  Error("malformed submodule block record in AST file");
4959  return Failure;
4960  }
4961 
4962  ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4963  bool First = true;
4964  Module *CurrentModule = nullptr;
4965  RecordData Record;
4966  while (true) {
4967  llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4968 
4969  switch (Entry.Kind) {
4970  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4972  Error("malformed block record in AST file");
4973  return Failure;
4974  case llvm::BitstreamEntry::EndBlock:
4975  return Success;
4976  case llvm::BitstreamEntry::Record:
4977  // The interesting case.
4978  break;
4979  }
4980 
4981  // Read a record.
4982  StringRef Blob;
4983  Record.clear();
4984  auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4985 
4986  if ((Kind == SUBMODULE_METADATA) != First) {
4987  Error("submodule metadata record should be at beginning of block");
4988  return Failure;
4989  }
4990  First = false;
4991 
4992  // Submodule information is only valid if we have a current module.
4993  // FIXME: Should we error on these cases?
4994  if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4996  continue;
4997 
4998  switch (Kind) {
4999  default: // Default behavior: ignore.
5000  break;
5001 
5002  case SUBMODULE_DEFINITION: {
5003  if (Record.size() < 12) {
5004  Error("malformed module definition");
5005  return Failure;
5006  }
5007 
5008  StringRef Name = Blob;
5009  unsigned Idx = 0;
5010  SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5011  SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5012  Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5013  bool IsFramework = Record[Idx++];
5014  bool IsExplicit = Record[Idx++];
5015  bool IsSystem = Record[Idx++];
5016  bool IsExternC = Record[Idx++];
5017  bool InferSubmodules = Record[Idx++];
5018  bool InferExplicitSubmodules = Record[Idx++];
5019  bool InferExportWildcard = Record[Idx++];
5020  bool ConfigMacrosExhaustive = Record[Idx++];
5021  bool ModuleMapIsPrivate = Record[Idx++];
5022 
5023  Module *ParentModule = nullptr;
5024  if (Parent)
5025  ParentModule = getSubmodule(Parent);
5026 
5027  // Retrieve this (sub)module from the module map, creating it if
5028  // necessary.
5029  CurrentModule =
5030  ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5031  .first;
5032 
5033  // FIXME: set the definition loc for CurrentModule, or call
5034  // ModMap.setInferredModuleAllowedBy()
5035 
5036  SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5037  if (GlobalIndex >= SubmodulesLoaded.size() ||
5038  SubmodulesLoaded[GlobalIndex]) {
5039  Error("too many submodules");
5040  return Failure;
5041  }
5042 
5043  if (!ParentModule) {
5044  if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5045  // Don't emit module relocation error if we have -fno-validate-pch
5046  if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5047  CurFile != F.File) {
5048  if (!Diags.isDiagnosticInFlight()) {
5049  Diag(diag::err_module_file_conflict)
5050  << CurrentModule->getTopLevelModuleName()
5051  << CurFile->getName()
5052  << F.File->getName();
5053  }
5054  return Failure;
5055  }
5056  }
5057 
5058  CurrentModule->setASTFile(F.File);
5059  CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5060  }
5061 
5062  CurrentModule->Kind = Kind;
5063  CurrentModule->Signature = F.Signature;
5064  CurrentModule->IsFromModuleFile = true;
5065  CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5066  CurrentModule->IsExternC = IsExternC;
5067  CurrentModule->InferSubmodules = InferSubmodules;
5068  CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5069  CurrentModule->InferExportWildcard = InferExportWildcard;
5070  CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5071  CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5072  if (DeserializationListener)
5073  DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5074 
5075  SubmodulesLoaded[GlobalIndex] = CurrentModule;
5076 
5077  // Clear out data that will be replaced by what is in the module file.
5078  CurrentModule->LinkLibraries.clear();
5079  CurrentModule->ConfigMacros.clear();
5080  CurrentModule->UnresolvedConflicts.clear();
5081  CurrentModule->Conflicts.clear();
5082 
5083  // The module is available unless it's missing a requirement; relevant
5084  // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5085  // Missing headers that were present when the module was built do not
5086  // make it unavailable -- if we got this far, this must be an explicitly
5087  // imported module file.
5088  CurrentModule->Requirements.clear();
5089  CurrentModule->MissingHeaders.clear();
5090  CurrentModule->IsMissingRequirement =
5091  ParentModule && ParentModule->IsMissingRequirement;
5092  CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5093  break;
5094  }
5095 
5097  std::string Filename = Blob;
5098  ResolveImportedPath(F, Filename);
5099  if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5100  if (!CurrentModule->getUmbrellaHeader())
5101  ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5102  else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5103  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5104  Error("mismatched umbrella headers in submodule");
5105  return OutOfDate;
5106  }
5107  }
5108  break;
5109  }
5110 
5111  case SUBMODULE_HEADER:
5114  // We lazily associate headers with their modules via the HeaderInfo table.
5115  // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5116  // of complete filenames or remove it entirely.
5117  break;
5118 
5121  // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5122  // them here.
5123  break;
5124 
5125  case SUBMODULE_TOPHEADER:
5126  CurrentModule->addTopHeaderFilename(Blob);
5127  break;
5128 
5129  case SUBMODULE_UMBRELLA_DIR: {
5130  std::string Dirname = Blob;
5131  ResolveImportedPath(F, Dirname);
5132  if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5133  if (!CurrentModule->getUmbrellaDir())
5134  ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5135  else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5136  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5137  Error("mismatched umbrella directories in submodule");
5138  return OutOfDate;
5139  }
5140  }
5141  break;
5142  }
5143 
5144  case SUBMODULE_METADATA: {
5145  F.BaseSubmoduleID = getTotalNumSubmodules();
5146  F.LocalNumSubmodules = Record[0];
5147  unsigned LocalBaseSubmoduleID = Record[1];
5148  if (F.LocalNumSubmodules > 0) {
5149  // Introduce the global -> local mapping for submodules within this
5150  // module.
5151  GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5152 
5153  // Introduce the local -> global mapping for submodules within this
5154  // module.
5156  std::make_pair(LocalBaseSubmoduleID,
5157  F.BaseSubmoduleID - LocalBaseSubmoduleID));
5158 
5159  SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5160  }
5161  break;
5162  }
5163 
5164  case SUBMODULE_IMPORTS:
5165  for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5166  UnresolvedModuleRef Unresolved;
5167  Unresolved.File = &F;
5168  Unresolved.Mod = CurrentModule;
5169  Unresolved.ID = Record[Idx];
5170  Unresolved.Kind = UnresolvedModuleRef::Import;
5171  Unresolved.IsWildcard = false;
5172  UnresolvedModuleRefs.push_back(Unresolved);
5173  }
5174  break;
5175 
5176  case SUBMODULE_EXPORTS:
5177  for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5178  UnresolvedModuleRef Unresolved;
5179  Unresolved.File = &F;
5180  Unresolved.Mod = CurrentModule;
5181  Unresolved.ID = Record[Idx];
5182  Unresolved.Kind = UnresolvedModuleRef::Export;
5183  Unresolved.IsWildcard = Record[Idx + 1];
5184  UnresolvedModuleRefs.push_back(Unresolved);
5185  }
5186 
5187  // Once we've loaded the set of exports, there's no reason to keep
5188  // the parsed, unresolved exports around.
5189  CurrentModule->UnresolvedExports.clear();
5190  break;
5191 
5192  case SUBMODULE_REQUIRES:
5193  CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5194  PP.getTargetInfo());
5195  break;
5196 
5198  ModMap.resolveLinkAsDependencies(CurrentModule);
5199  CurrentModule->LinkLibraries.push_back(
5200  Module::LinkLibrary(Blob, Record[0]));
5201  break;
5202 
5204  CurrentModule->ConfigMacros.push_back(Blob.str());
5205  break;
5206 
5207  case SUBMODULE_CONFLICT: {
5208  UnresolvedModuleRef Unresolved;
5209  Unresolved.File = &F;
5210  Unresolved.Mod = CurrentModule;
5211  Unresolved.ID = Record[0];
5212  Unresolved.Kind = UnresolvedModuleRef::Conflict;
5213  Unresolved.IsWildcard = false;
5214  Unresolved.String = Blob;
5215  UnresolvedModuleRefs.push_back(Unresolved);
5216  break;
5217  }
5218 
5219  case SUBMODULE_INITIALIZERS: {
5220  if (!ContextObj)
5221  break;
5223  for (auto &ID : Record)
5224  Inits.push_back(getGlobalDeclID(F, ID));
5225  ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5226  break;
5227  }
5228 
5229  case SUBMODULE_EXPORT_AS:
5230  CurrentModule->ExportAsModule = Blob.str();
5231  ModMap.addLinkAsDependency(CurrentModule);
5232  break;
5233  }
5234  }
5235 }
5236 
5237 /// Parse the record that corresponds to a LangOptions data
5238 /// structure.
5239 ///
5240 /// This routine parses the language options from the AST file and then gives
5241 /// them to the AST listener if one is set.
5242 ///
5243 /// \returns true if the listener deems the file unacceptable, false otherwise.
5244 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5245  bool Complain,
5246  ASTReaderListener &Listener,
5247  bool AllowCompatibleDifferences) {
5248  LangOptions LangOpts;
5249  unsigned Idx = 0;
5250 #define LANGOPT(Name, Bits, Default, Description) \
5251  LangOpts.Name = Record[Idx++];
5252 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5253  LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5254 #include "clang/Basic/LangOptions.def"
5255 #define SANITIZER(NAME, ID) \
5256  LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5257 #include "clang/Basic/Sanitizers.def"
5258 
5259  for (unsigned N = Record[Idx++]; N; --N)
5260  LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5261 
5262  ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5263  VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5264  LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5265 
5266  LangOpts.CurrentModule = ReadString(Record, Idx);
5267 
5268  // Comment options.
5269  for (unsigned N = Record[Idx++]; N; --N) {
5270  LangOpts.CommentOpts.BlockCommandNames.push_back(
5271  ReadString(Record, Idx));
5272  }
5273  LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5274 
5275  // OpenMP offloading options.
5276  for (unsigned N = Record[Idx++]; N; --N) {
5277  LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5278  }
5279 
5280  LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5281 
5282  return Listener.ReadLanguageOptions(LangOpts, Complain,
5283  AllowCompatibleDifferences);
5284 }
5285 
5286 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5287  ASTReaderListener &Listener,
5288  bool AllowCompatibleDifferences) {
5289  unsigned Idx = 0;
5290  TargetOptions TargetOpts;
5291  TargetOpts.Triple = ReadString(Record, Idx);
5292  TargetOpts.CPU = ReadString(Record, Idx);
5293  TargetOpts.ABI = ReadString(Record, Idx);
5294  for (unsigned N = Record[Idx++]; N; --N) {
5295  TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5296  }
5297  for (unsigned N = Record[Idx++]; N; --N) {
5298  TargetOpts.Features.push_back(ReadString(Record, Idx));
5299  }
5300 
5301  return Listener.ReadTargetOptions(TargetOpts, Complain,
5302  AllowCompatibleDifferences);
5303 }
5304 
5305 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5306  ASTReaderListener &Listener) {
5308  unsigned Idx = 0;
5309 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5310 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5311  DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5312 #include "clang/Basic/DiagnosticOptions.def"
5313 
5314  for (unsigned N = Record[Idx++]; N; --N)
5315  DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5316  for (unsigned N = Record[Idx++]; N; --N)
5317  DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5318 
5319  return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5320 }
5321 
5322 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5323  ASTReaderListener &Listener) {
5324  FileSystemOptions FSOpts;
5325  unsigned Idx = 0;
5326  FSOpts.WorkingDir = ReadString(Record, Idx);
5327  return Listener.ReadFileSystemOptions(FSOpts, Complain);
5328 }
5329 
5330 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5331  bool Complain,
5332  ASTReaderListener &Listener) {
5333  HeaderSearchOptions HSOpts;
5334  unsigned Idx = 0;
5335  HSOpts.Sysroot = ReadString(Record, Idx);
5336 
5337  // Include entries.
5338  for (unsigned N = Record[Idx++]; N; --N) {
5339  std::string Path = ReadString(Record, Idx);
5341  = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5342  bool IsFramework = Record[Idx++];
5343  bool IgnoreSysRoot = Record[Idx++];
5344  HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5345  IgnoreSysRoot);
5346  }
5347 
5348  // System header prefixes.
5349  for (unsigned N = Record[Idx++]; N; --N) {
5350  std::string Prefix = ReadString(Record, Idx);
5351  bool IsSystemHeader = Record[Idx++];
5352  HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5353  }
5354 
5355  HSOpts.ResourceDir = ReadString(Record, Idx);
5356  HSOpts.ModuleCachePath = ReadString(Record, Idx);
5357  HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5358  HSOpts.DisableModuleHash = Record[Idx++];
5359  HSOpts.ImplicitModuleMaps = Record[Idx++];
5360  HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5361  HSOpts.UseBuiltinIncludes = Record[Idx++];
5362  HSOpts.UseStandardSystemIncludes = Record[Idx++];
5363  HSOpts.UseStandardCXXIncludes = Record[Idx++];
5364  HSOpts.UseLibcxx = Record[Idx++];
5365  std::string SpecificModuleCachePath = ReadString(Record, Idx);
5366 
5367  return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5368  Complain);
5369 }
5370 
5371 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5372  bool Complain,
5373  ASTReaderListener &Listener,
5374  std::string &SuggestedPredefines) {
5375  PreprocessorOptions PPOpts;
5376  unsigned Idx = 0;
5377 
5378  // Macro definitions/undefs
5379  for (unsigned N = Record[Idx++]; N; --N) {
5380  std::string Macro = ReadString(Record, Idx);
5381  bool IsUndef = Record[Idx++];
5382  PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5383  }
5384 
5385  // Includes
5386  for (unsigned N = Record[Idx++]; N; --N) {
5387  PPOpts.Includes.push_back(ReadString(Record, Idx));
5388  }
5389 
5390  // Macro Includes
5391  for (unsigned N = Record[Idx++]; N; --N) {
5392  PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5393  }
5394 
5395  PPOpts.UsePredefines = Record[Idx++];
5396  PPOpts.DetailedRecord = Record[Idx++];
5397  PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5398  PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
5399  PPOpts.ObjCXXARCStandardLibrary =
5400  static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5401  SuggestedPredefines.clear();
5402  return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5403  SuggestedPredefines);
5404 }
5405 
5406 std::pair<ModuleFile *, unsigned>
5407 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5409  I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5410  assert(I != GlobalPreprocessedEntityMap.end() &&
5411  "Corrupted global preprocessed entity map");
5412  ModuleFile *M = I->second;
5413  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5414  return std::make_pair(M, LocalIndex);
5415 }
5416 
5417 llvm::iterator_range<PreprocessingRecord::iterator>
5418 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5419  if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5420  return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5422 
5423  return llvm::make_range(PreprocessingRecord::iterator(),
5425 }
5426 
5427 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5429  return llvm::make_range(
5430  ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5431  ModuleDeclIterator(this, &Mod,
5432  Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5433 }
5434 
5436  auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5437  assert(I != GlobalSkippedRangeMap.end() &&
5438  "Corrupted global skipped range map");
5439  ModuleFile *M = I->second;
5440  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5441  assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5442  PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5443  SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5444  TranslateSourceLocation(*M, RawRange.getEnd()));
5445  assert(Range.isValid());
5446  return Range;
5447 }
5448 
5450  PreprocessedEntityID PPID = Index+1;
5451  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5452  ModuleFile &M = *PPInfo.first;
5453  unsigned LocalIndex = PPInfo.second;
5454  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5455 
5456  if (!PP.getPreprocessingRecord()) {
5457  Error("no preprocessing record");
5458  return nullptr;
5459  }
5460 
5462  M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5463 
5464  llvm::BitstreamEntry Entry =
5465  M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5466  if (Entry.Kind != llvm::BitstreamEntry::Record)
5467  return nullptr;
5468 
5469  // Read the record.
5470  SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5471  TranslateSourceLocation(M, PPOffs.getEnd()));
5472  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5473  StringRef Blob;
5474  RecordData Record;
5477  Entry.ID, Record, &Blob);
5478  switch (RecType) {
5479  case PPD_MACRO_EXPANSION: {
5480  bool isBuiltin = Record[0];
5481  IdentifierInfo *Name = nullptr;
5482  MacroDefinitionRecord *Def = nullptr;
5483  if (isBuiltin)
5484  Name = getLocalIdentifier(M, Record[1]);
5485  else {
5486  PreprocessedEntityID GlobalID =
5487  getGlobalPreprocessedEntityID(M, Record[1]);
5488  Def = cast<MacroDefinitionRecord>(
5489  PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5490  }
5491 
5492  MacroExpansion *ME;
5493  if (isBuiltin)
5494  ME = new (PPRec) MacroExpansion(Name, Range);
5495  else
5496  ME = new (PPRec) MacroExpansion(Def, Range);
5497 
5498  return ME;
5499  }
5500 
5501  case PPD_MACRO_DEFINITION: {
5502  // Decode the identifier info and then check again; if the macro is
5503  // still defined and associated with the identifier,
5504  IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5505  MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5506 
5507  if (DeserializationListener)
5508  DeserializationListener->MacroDefinitionRead(PPID, MD);
5509 
5510  return MD;
5511  }
5512 
5513  case PPD_INCLUSION_DIRECTIVE: {
5514  const char *FullFileNameStart = Blob.data() + Record[0];
5515  StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5516  const FileEntry *File = nullptr;
5517  if (!FullFileName.empty())
5518  File = PP.getFileManager().getFile(FullFileName);
5519 
5520  // FIXME: Stable encoding
5522  = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5524  = new (PPRec) InclusionDirective(PPRec, Kind,
5525  StringRef(Blob.data(), Record[0]),
5526  Record[1], Record[3],
5527  File,
5528  Range);
5529  return ID;
5530  }
5531  }
5532 
5533  llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5534 }
5535 
5536 /// Find the next module that contains entities and return the ID
5537 /// of the first entry.
5538 ///
5539 /// \param SLocMapI points at a chunk of a module that contains no
5540 /// preprocessed entities or the entities it contains are not the ones we are
5541 /// looking for.
5542 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5543  GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5544  ++SLocMapI;
5546  EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5547  ModuleFile &M = *SLocMapI->second;
5549  return M.BasePreprocessedEntityID;
5550  }
5551 
5552  return getTotalNumPreprocessedEntities();
5553 }
5554 
5555 namespace {
5556 
5557 struct PPEntityComp {
5558  const ASTReader &Reader;
5559  ModuleFile &M;
5560 
5561  PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5562 
5563  bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5564  SourceLocation LHS = getLoc(L);
5565  SourceLocation RHS = getLoc(R);
5566  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5567  }
5568 
5569  bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5570  SourceLocation LHS = getLoc(L);
5571  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5572  }
5573 
5574  bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5575  SourceLocation RHS = getLoc(R);
5576  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5577  }
5578 
5579  SourceLocation getLoc(const PPEntityOffset &PPE) const {
5580  return Reader.TranslateSourceLocation(M, PPE.getBegin());
5581  }
5582 };
5583 
5584 } // namespace
5585 
5586 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5587  bool EndsAfter) const {
5588  if (SourceMgr.isLocalSourceLocation(Loc))
5589  return getTotalNumPreprocessedEntities();
5590 
5591  GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5592  SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5593  assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5594  "Corrupted global sloc offset map");
5595 
5596  if (SLocMapI->second->NumPreprocessedEntities == 0)
5597  return findNextPreprocessedEntity(SLocMapI);
5598 
5599  ModuleFile &M = *SLocMapI->second;
5600 
5601  using pp_iterator = const PPEntityOffset *;
5602 
5603  pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5604  pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5605 
5606  size_t Count = M.NumPreprocessedEntities;
5607  size_t Half;
5608  pp_iterator First = pp_begin;
5609  pp_iterator PPI;
5610 
5611  if (EndsAfter) {
5612  PPI = std::upper_bound(pp_begin, pp_end, Loc,
5613  PPEntityComp(*this, M));
5614  } else {
5615  // Do a binary search manually instead of using std::lower_bound because
5616  // The end locations of entities may be unordered (when a macro expansion
5617  // is inside another macro argument), but for this case it is not important
5618  // whether we get the first macro expansion or its containing macro.
5619  while (Count > 0) {
5620  Half = Count / 2;
5621  PPI = First;
5622  std::advance(PPI, Half);
5623  if (SourceMgr.isBeforeInTranslationUnit(
5624  TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5625  First = PPI;
5626  ++First;
5627  Count = Count - Half - 1;
5628  } else
5629  Count = Half;
5630  }
5631  }
5632 
5633  if (PPI == pp_end)
5634  return findNextPreprocessedEntity(SLocMapI);
5635 
5636  return M.BasePreprocessedEntityID + (PPI - pp_begin);
5637 }
5638 
5639 /// Returns a pair of [Begin, End) indices of preallocated
5640 /// preprocessed entities that \arg Range encompasses.
5641 std::pair<unsigned, unsigned>
5643  if (Range.isInvalid())
5644  return std::make_pair(0,0);
5645  assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5646 
5647  PreprocessedEntityID BeginID =
5648  findPreprocessedEntity(Range.getBegin(), false);
5649  PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5650  return std::make_pair(BeginID, EndID);
5651 }
5652 
5653 /// Optionally returns true or false if the preallocated preprocessed
5654 /// entity with index \arg Index came from file \arg FID.
5656  FileID FID) {
5657  if (FID.isInvalid())
5658  return false;
5659 
5660  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5661  ModuleFile &M = *PPInfo.first;
5662  unsigned LocalIndex = PPInfo.second;
5663  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5664 
5665  SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5666  if (Loc.isInvalid())
5667  return false;
5668 
5669  if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5670  return true;
5671  else
5672  return false;
5673 }
5674 
5675 namespace {
5676 
5677  /// Visitor used to search for information about a header file.
5678  class HeaderFileInfoVisitor {
5679  const FileEntry *FE;
5681 
5682  public:
5683  explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5684 
5685  bool operator()(ModuleFile &M) {
5687  = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5688  if (!Table)
5689  return false;
5690 
5691  // Look in the on-disk hash table for an entry for this file name.
5692  HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5693  if (Pos == Table->end())
5694  return false;
5695 
5696  HFI = *Pos;
5697  return true;
5698  }
5699 
5700  Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5701  };
5702 
5703 } // namespace
5704 
5706  HeaderFileInfoVisitor Visitor(FE);
5707  ModuleMgr.visit(Visitor);
5708  if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5709  return *HFI;
5710 
5711  return HeaderFileInfo();
5712 }
5713 
5715  using DiagState = DiagnosticsEngine::DiagState;
5716  SmallVector<DiagState *, 32> DiagStates;
5717 
5718  for (ModuleFile &F : ModuleMgr) {
5719  unsigned Idx = 0;
5720  auto &Record = F.PragmaDiagMappings;
5721  if (Record.empty())
5722  continue;
5723 
5724  DiagStates.clear();
5725 
5726  auto ReadDiagState =
5727  [&](const DiagState &BasedOn, SourceLocation Loc,
5728  bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5729  unsigned BackrefID = Record[Idx++];
5730  if (BackrefID != 0)
5731  return DiagStates[BackrefID - 1];
5732 
5733  // A new DiagState was created here.
5734  Diag.DiagStates.push_back(BasedOn);
5735  DiagState *NewState = &Diag.DiagStates.back();
5736  DiagStates.push_back(NewState);
5737  unsigned Size = Record[Idx++];
5738  assert(Idx + Size * 2 <= Record.size() &&
5739  "Invalid data, not enough diag/map pairs");
5740  while (Size--) {
5741  unsigned DiagID = Record[Idx++];
5742  DiagnosticMapping NewMapping =
5743  DiagnosticMapping::deserialize(Record[Idx++]);
5744  if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5745  continue;
5746 
5747  DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5748 
5749  // If this mapping was specified as a warning but the severity was
5750  // upgraded due to diagnostic settings, simulate the current diagnostic
5751  // settings (and use a warning).
5752  if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5754  NewMapping.setUpgradedFromWarning(false);
5755  }
5756 
5757  Mapping = NewMapping;
5758  }
5759  return NewState;
5760  };
5761 
5762  // Read the first state.
5763  DiagState *FirstState;
5764  if (F.Kind == MK_ImplicitModule) {
5765  // Implicitly-built modules are reused with different diagnostic
5766  // settings. Use the initial diagnostic state from Diag to simulate this
5767  // compilation's diagnostic settings.
5768  FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5769  DiagStates.push_back(FirstState);
5770 
5771  // Skip the initial diagnostic state from the serialized module.
5772  assert(Record[1] == 0 &&
5773  "Invalid data, unexpected backref in initial state");
5774  Idx = 3 + Record[2] * 2;
5775  assert(Idx < Record.size() &&
5776  "Invalid data, not enough state change pairs in initial state");
5777  } else if (F.isModule()) {
5778  // For an explicit module, preserve the flags from the module build
5779  // command line (-w, -Weverything, -Werror, ...) along with any explicit
5780  // -Wblah flags.
5781  unsigned Flags = Record[Idx++];
5782  DiagState Initial;
5783  Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5784  Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5785  Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5786  Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5787  Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5788  Initial.ExtBehavior = (diag::Severity)Flags;
5789  FirstState = ReadDiagState(Initial, SourceLocation(), true);
5790 
5791  assert(F.OriginalSourceFileID.isValid());
5792 
5793  // Set up the root buffer of the module to start with the initial
5794  // diagnostic state of the module itself, to cover files that contain no
5795  // explicit transitions (for which we did not serialize anything).
5796  Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5797  .StateTransitions.push_back({FirstState, 0});
5798  } else {
5799  // For prefix ASTs, start with whatever the user configured on the
5800  // command line.
5801  Idx++; // Skip flags.
5802  FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5803  SourceLocation(), false);
5804  }
5805 
5806  // Read the state transitions.
5807  unsigned NumLocations = Record[Idx++];
5808  while (NumLocations--) {
5809  assert(Idx < Record.size() &&
5810  "Invalid data, missing pragma diagnostic states");
5811  SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5812  auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5813  assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
5814  assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5815  unsigned Transitions = Record[Idx++];
5816 
5817  // Note that we don't need to set up Parent/ParentOffset here, because
5818  // we won't be changing the diagnostic state within imported FileIDs
5819  // (other than perhaps appending to the main source file, which has no
5820  // parent).
5821  auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5822  F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5823  for (unsigned I = 0; I != Transitions; ++I) {
5824  unsigned Offset = Record[Idx++];
5825  auto *State =
5826  ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5827  F.StateTransitions.push_back({State, Offset});
5828  }
5829  }
5830 
5831  // Read the final state.
5832  assert(Idx < Record.size() &&
5833  "Invalid data, missing final pragma diagnostic state");
5834  SourceLocation CurStateLoc =
5835  ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5836  auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5837 
5838  if (!F.isModule()) {
5839  Diag.DiagStatesByLoc.CurDiagState = CurState;
5840  Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5841 
5842  // Preserve the property that the imaginary root file describes the
5843  // current state.
5844  FileID NullFile;
5845  auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5846  if (T.empty())
5847  T.push_back({CurState, 0});
5848  else
5849  T[0].State = CurState;
5850  }
5851 
5852  // Don't try to read these mappings again.
5853  Record.clear();
5854  }
5855 }
5856 
5857 /// Get the correct cursor and offset for loading a type.
5858 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5859  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5860  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5861  ModuleFile *M = I->second;
5862  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5863 }
5864 
5865 /// Read and return the type with the given index..
5866 ///
5867 /// The index is the type ID, shifted and minus the number of predefs. This
5868 /// routine actually reads the record corresponding to the type at the given
5869 /// location. It is a helper routine for GetType, which deals with reading type
5870 /// IDs.
5871 QualType ASTReader::readTypeRecord(unsigned Index) {
5872  assert(ContextObj && "reading type with no AST context");
5873  ASTContext &Context = *ContextObj;
5874  RecordLocation Loc = TypeCursorForIndex(Index);
5875  BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5876 
5877  // Keep track of where we are in the stream, then jump back there
5878  // after reading this type.
5879  SavedStreamPosition SavedPosition(DeclsCursor);
5880 
5881  ReadingKindTracker ReadingKind(Read_Type, *this);
5882 
5883  // Note that we are loading a type record.
5884  Deserializing AType(this);
5885 
5886  unsigned Idx = 0;
5887  DeclsCursor.JumpToBit(Loc.Offset);
5888  RecordData Record;
5889  unsigned Code = DeclsCursor.ReadCode();
5890  switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5891  case TYPE_EXT_QUAL: {
5892  if (Record.size() != 2) {
5893  Error("Incorrect encoding of extended qualifier type");
5894  return QualType();
5895  }
5896  QualType Base = readType(*Loc.F, Record, Idx);
5897  Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5898  return Context.getQualifiedType(Base, Quals);
5899  }
5900 
5901  case TYPE_COMPLEX: {
5902  if (Record.size() != 1) {
5903  Error("Incorrect encoding of complex type");
5904  return QualType();
5905  }
5906  QualType ElemType = readType(*Loc.F, Record, Idx);
5907  return Context.getComplexType(ElemType);
5908  }
5909 
5910  case TYPE_POINTER: {
5911  if (Record.size() != 1) {
5912  Error("Incorrect encoding of pointer type");
5913  return QualType();
5914  }
5915  QualType PointeeType = readType(*Loc.F, Record, Idx);
5916  return Context.getPointerType(PointeeType);
5917  }
5918 
5919  case TYPE_DECAYED: {
5920  if (Record.size() != 1) {
5921  Error("Incorrect encoding of decayed type");
5922  return QualType();
5923  }
5924  QualType OriginalType = readType(*Loc.F, Record, Idx);
5925  QualType DT = Context.getAdjustedParameterType(OriginalType);
5926  if (!isa<DecayedType>(DT))
5927  Error("Decayed type does not decay");
5928  return DT;
5929  }
5930 
5931  case TYPE_ADJUSTED: {
5932  if (Record.size() != 2) {
5933  Error("Incorrect encoding of adjusted type");
5934  return QualType();
5935  }
5936  QualType OriginalTy = readType(*Loc.F, Record, Idx);
5937  QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5938  return Context.getAdjustedType(OriginalTy, AdjustedTy);
5939  }
5940 
5941  case TYPE_BLOCK_POINTER: {
5942  if (Record.size() != 1) {
5943  Error("Incorrect encoding of block pointer type");
5944  return QualType();
5945  }
5946  QualType PointeeType = readType(*Loc.F, Record, Idx);
5947  return Context.getBlockPointerType(PointeeType);
5948  }
5949 
5950  case TYPE_LVALUE_REFERENCE: {
5951  if (Record.size() != 2) {
5952  Error("Incorrect encoding of lvalue reference type");
5953  return QualType();
5954  }
5955  QualType PointeeType = readType(*Loc.F, Record, Idx);
5956  return Context.getLValueReferenceType(PointeeType, Record[1]);
5957  }
5958 
5959  case TYPE_RVALUE_REFERENCE: {
5960  if (Record.size() != 1) {
5961  Error("Incorrect encoding of rvalue reference type");
5962  return QualType();
5963  }
5964  QualType PointeeType = readType(*Loc.F, Record, Idx);
5965  return Context.getRValueReferenceType(PointeeType);
5966  }
5967 
5968  case TYPE_MEMBER_POINTER: {
5969  if (Record.size() != 2) {
5970  Error("Incorrect encoding of member pointer type");
5971  return QualType();
5972  }
5973  QualType PointeeType = readType(*Loc.F, Record, Idx);
5974  QualType ClassType = readType(*Loc.F, Record, Idx);
5975  if (PointeeType.isNull() || ClassType.isNull())
5976  return QualType();
5977 
5978  return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5979  }
5980 
5981  case TYPE_CONSTANT_ARRAY: {
5982  QualType ElementType = readType(*Loc.F, Record, Idx);
5984  unsigned IndexTypeQuals = Record[2];
5985  unsigned Idx = 3;
5986  llvm::APInt Size = ReadAPInt(Record, Idx);
5987  return Context.getConstantArrayType(ElementType, Size,
5988  ASM, IndexTypeQuals);
5989  }
5990 
5991  case TYPE_INCOMPLETE_ARRAY: {
5992  QualType ElementType = readType(*Loc.F, Record, Idx);
5994  unsigned IndexTypeQuals = Record[2];
5995  return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5996  }
5997 
5998  case TYPE_VARIABLE_ARRAY: {
5999  QualType ElementType = readType(*Loc.F, Record, Idx);
6001  unsigned IndexTypeQuals = Record[2];
6002  SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
6003  SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
6004  return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
6005  ASM, IndexTypeQuals,
6006  SourceRange(LBLoc, RBLoc));
6007  }
6008 
6009  case TYPE_VECTOR: {
6010  if (Record.size() != 3) {
6011  Error("incorrect encoding of vector type in AST file");
6012  return QualType();
6013  }
6014 
6015  QualType ElementType = readType(*Loc.F, Record, Idx);
6016  unsigned NumElements = Record[1];
6017  unsigned VecKind = Record[2];
6018  return Context.getVectorType(ElementType, NumElements,
6019  (VectorType::VectorKind)VecKind);
6020  }
6021 
6022  case TYPE_EXT_VECTOR: {
6023  if (Record.size() != 3) {
6024  Error("incorrect encoding of extended vector type in AST file");
6025  return QualType();
6026  }
6027 
6028  QualType ElementType = readType(*Loc.F, Record, Idx);
6029  unsigned NumElements = Record[1];
6030  return Context.getExtVectorType(ElementType, NumElements);
6031  }
6032 
6033  case TYPE_FUNCTION_NO_PROTO: {
6034  if (Record.size() != 8) {
6035  Error("incorrect encoding of no-proto function type");
6036  return QualType();
6037  }
6038  QualType ResultType = readType(*Loc.F, Record, Idx);
6039  FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
6040  (CallingConv)Record[4], Record[5], Record[6],
6041  Record[7]);
6042  return Context.getFunctionNoProtoType(ResultType, Info);
6043  }
6044 
6045  case TYPE_FUNCTION_PROTO: {
6046  QualType ResultType = readType(*Loc.F, Record, Idx);
6047 
6049  EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
6050  /*hasregparm*/ Record[2],
6051  /*regparm*/ Record[3],
6052  static_cast<CallingConv>(Record[4]),
6053  /*produces*/ Record[5],
6054  /*nocallersavedregs*/ Record[6],
6055  /*nocfcheck*/ Record[7]);
6056 
6057  unsigned Idx = 8;
6058 
6059  EPI.Variadic = Record[Idx++];
6060  EPI.HasTrailingReturn = Record[Idx++];
6061  EPI.TypeQuals = Record[Idx++];
6062  EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
6063  SmallVector<QualType, 8> ExceptionStorage;
6064  readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
6065 
6066  unsigned NumParams = Record[Idx++];
6067  SmallVector<QualType, 16> ParamTypes;
6068  for (unsigned I = 0; I != NumParams; ++I)
6069  ParamTypes.push_back(readType(*Loc.F, Record, Idx));
6070 
6072  if (Idx != Record.size()) {
6073  for (unsigned I = 0; I != NumParams; ++I)
6074  ExtParameterInfos.push_back(
6076  ::getFromOpaqueValue(Record[Idx++]));
6077  EPI.ExtParameterInfos = ExtParameterInfos.data();
6078  }
6079 
6080  assert(Idx == Record.size());
6081 
6082  return Context.getFunctionType(ResultType, ParamTypes, EPI);
6083  }
6084 
6085  case TYPE_UNRESOLVED_USING: {
6086  unsigned Idx = 0;
6087  return Context.getTypeDeclType(
6088  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
6089  }
6090 
6091  case TYPE_TYPEDEF: {
6092  if (Record.size() != 2) {
6093  Error("incorrect encoding of typedef type");
6094  return QualType();
6095  }
6096  unsigned Idx = 0;
6097  TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
6098  QualType Canonical = readType(*Loc.F, Record, Idx);
6099  if (!Canonical.isNull())
6100  Canonical = Context.getCanonicalType(Canonical);
6101  return Context.getTypedefType(Decl, Canonical);
6102  }
6103 
6104  case TYPE_TYPEOF_EXPR:
6105  return Context.getTypeOfExprType(ReadExpr(*Loc.F));
6106 
6107  case TYPE_TYPEOF: {
6108  if (Record.size() != 1) {
6109  Error("incorrect encoding of typeof(type) in AST file");
6110  return QualType();
6111  }
6112  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6113  return Context.getTypeOfType(UnderlyingType);
6114  }
6115 
6116  case TYPE_DECLTYPE: {
6117  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6118  return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
6119  }
6120 
6121  case TYPE_UNARY_TRANSFORM: {
6122  QualType BaseType = readType(*Loc.F, Record, Idx);
6123  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6125  return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
6126  }
6127 
6128  case TYPE_AUTO: {
6129  QualType Deduced = readType(*Loc.F, Record, Idx);
6130  AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
6131  bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6132  return Context.getAutoType(Deduced, Keyword, IsDependent);
6133  }
6134 
6136  TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6137  QualType Deduced = readType(*Loc.F, Record, Idx);
6138  bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6139  return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6140  IsDependent);
6141  }
6142 
6143  case TYPE_RECORD: {
6144  if (Record.size() != 2) {
6145  Error("incorrect encoding of record type");
6146  return QualType();
6147  }
6148  unsigned Idx = 0;
6149  bool IsDependent = Record[Idx++];
6150  RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6151  RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6152  QualType T = Context.getRecordType(RD);
6153  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6154  return T;
6155  }
6156 
6157  case TYPE_ENUM: {
6158  if (Record.size() != 2) {
6159  Error("incorrect encoding of enum type");
6160  return QualType();
6161  }
6162  unsigned Idx = 0;
6163  bool IsDependent = Record[Idx++];
6164  QualType T
6165  = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6166  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6167  return T;
6168  }
6169 
6170  case TYPE_ATTRIBUTED: {
6171  if (Record.size() != 3) {
6172  Error("incorrect encoding of attributed type");
6173  return QualType();
6174  }
6175  QualType modifiedType = readType(*Loc.F, Record, Idx);
6176  QualType equivalentType = readType(*Loc.F, Record, Idx);
6177  AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6178  return Context.getAttributedType(kind, modifiedType, equivalentType);
6179  }
6180 
6181  case TYPE_PAREN: {
6182  if (Record.size() != 1) {
6183  Error("incorrect encoding of paren type");
6184  return QualType();
6185  }
6186  QualType InnerType = readType(*Loc.F, Record, Idx);
6187  return Context.getParenType(InnerType);
6188  }
6189 
6190  case TYPE_PACK_EXPANSION: {
6191  if (Record.size() != 2) {
6192  Error("incorrect encoding of pack expansion type");
6193  return QualType();
6194  }
6195  QualType Pattern = readType(*Loc.F, Record, Idx);
6196  if (Pattern.isNull())
6197  return QualType();
6198  Optional<unsigned> NumExpansions;
6199  if (Record[1])
6200  NumExpansions = Record[1] - 1;
6201  return Context.getPackExpansionType(Pattern, NumExpansions);
6202  }
6203 
6204  case TYPE_ELABORATED: {
6205  unsigned Idx = 0;
6206  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6207  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6208  QualType NamedType = readType(*Loc.F, Record, Idx);
6209  TagDecl *OwnedTagDecl = ReadDeclAs<TagDecl>(*Loc.F, Record, Idx);
6210  return Context.getElaboratedType(Keyword, NNS, NamedType, OwnedTagDecl);
6211  }
6212 
6213  case TYPE_OBJC_INTERFACE: {
6214  unsigned Idx = 0;
6215  ObjCInterfaceDecl *ItfD
6216  = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6217  return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6218  }
6219 
6220  case TYPE_OBJC_TYPE_PARAM: {
6221  unsigned Idx = 0;
6223  = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6224  unsigned NumProtos = Record[Idx++];
6226  for (unsigned I = 0; I != NumProtos; ++I)
6227  Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6228  return Context.getObjCTypeParamType(Decl, Protos);
6229  }
6230 
6231  case TYPE_OBJC_OBJECT: {
6232  unsigned Idx = 0;
6233  QualType Base = readType(*Loc.F, Record, Idx);
6234  unsigned NumTypeArgs = Record[Idx++];
6235  SmallVector<QualType, 4> TypeArgs;
6236  for (unsigned I = 0; I != NumTypeArgs; ++I)
6237  TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6238  unsigned NumProtos = Record[Idx++];
6240  for (unsigned I = 0; I != NumProtos; ++I)
6241  Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6242  bool IsKindOf = Record[Idx++];
6243  return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6244  }
6245 
6246  case TYPE_OBJC_OBJECT_POINTER: {
6247  unsigned Idx = 0;
6248  QualType Pointee = readType(*Loc.F, Record, Idx);
6249  return Context.getObjCObjectPointerType(Pointee);
6250  }
6251 
6253  unsigned Idx = 0;
6254  QualType Parm = readType(*Loc.F, Record, Idx);
6255  QualType Replacement = readType(*Loc.F, Record, Idx);
6256  return Context.getSubstTemplateTypeParmType(
6257  cast<TemplateTypeParmType>(Parm),
6258  Context.getCanonicalType(Replacement));
6259  }
6260 
6262  unsigned Idx = 0;
6263  QualType Parm = readType(*Loc.F, Record, Idx);
6264  TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6265  return Context.getSubstTemplateTypeParmPackType(
6266  cast<TemplateTypeParmType>(Parm),
6267  ArgPack);
6268  }
6269 
6270  case TYPE_INJECTED_CLASS_NAME: {
6271  CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6272  QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6273  // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6274  // for AST reading, too much interdependencies.
6275  const Type *T = nullptr;
6276  for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6277  if (const Type *Existing = DI->getTypeForDecl()) {
6278  T = Existing;
6279  break;
6280  }
6281  }
6282  if (!T) {
6283  T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6284  for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6285  DI->setTypeForDecl(T);
6286  }
6287  return QualType(T, 0);
6288  }
6289 
6290  case TYPE_TEMPLATE_TYPE_PARM: {
6291  unsigned Idx = 0;
6292  unsigned Depth = Record[Idx++];
6293  unsigned Index = Record[Idx++];
6294  bool Pack = Record[Idx++];
6296  = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6297  return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6298  }
6299 
6300  case TYPE_DEPENDENT_NAME: {
6301  unsigned Idx = 0;
6302  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6303  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6304  const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6305  QualType Canon = readType(*Loc.F, Record, Idx);
6306  if (!Canon.isNull())
6307  Canon = Context.getCanonicalType(Canon);
6308  return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6309  }
6310 
6312  unsigned Idx = 0;
6313  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6314  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6315  const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6316  unsigned NumArgs = Record[Idx++];
6318  Args.reserve(NumArgs);
6319  while (NumArgs--)
6320  Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6321  return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6322  Args);
6323  }
6324 
6326  unsigned Idx = 0;
6327 
6328  // ArrayType
6329  QualType ElementType = readType(*Loc.F, Record, Idx);
6331  = (ArrayType::ArraySizeModifier)Record[Idx++];
6332  unsigned IndexTypeQuals = Record[Idx++];
6333 
6334  // DependentSizedArrayType
6335  Expr *NumElts = ReadExpr(*Loc.F);
6336  SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6337 
6338  return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6339  IndexTypeQuals, Brackets);
6340  }
6341 
6343  unsigned Idx = 0;
6344  bool IsDependent = Record[Idx++];
6345  TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6347  ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6348  QualType Underlying = readType(*Loc.F, Record, Idx);
6349  QualType T;
6350  if (Underlying.isNull())
6351  T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6352  else
6353  T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6354  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6355  return T;
6356  }
6357 
6358  case TYPE_ATOMIC: {
6359  if (Record.size() != 1) {
6360  Error("Incorrect encoding of atomic type");
6361  return QualType();
6362  }
6363  QualType ValueType = readType(*Loc.F, Record, Idx);
6364  return Context.getAtomicType(ValueType);
6365  }
6366 
6367  case TYPE_PIPE: {
6368  if (Record.size() != 2) {
6369  Error("Incorrect encoding of pipe type");
6370  return QualType();
6371  }
6372 
6373  // Reading the pipe element type.
6374  QualType ElementType = readType(*Loc.F, Record, Idx);
6375  unsigned ReadOnly = Record[1];
6376  return Context.getPipeType(ElementType, ReadOnly);
6377  }
6378 
6380  unsigned Idx = 0;
6381  QualType ElementType = readType(*Loc.F, Record, Idx);
6382  Expr *SizeExpr = ReadExpr(*Loc.F);
6383  SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6384  unsigned VecKind = Record[Idx];
6385 
6386  return Context.getDependentVectorType(ElementType, SizeExpr, AttrLoc,
6387  (VectorType::VectorKind)VecKind);
6388  }
6389 
6391  unsigned Idx = 0;
6392 
6393  // DependentSizedExtVectorType
6394  QualType ElementType = readType(*Loc.F, Record, Idx);
6395  Expr *SizeExpr = ReadExpr(*Loc.F);
6396  SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6397 
6398  return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6399  AttrLoc);
6400  }
6401 
6403  unsigned Idx = 0;
6404 
6405  // DependentAddressSpaceType
6406  QualType PointeeType = readType(*Loc.F, Record, Idx);
6407  Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
6408  SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6409 
6410  return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
6411  AttrLoc);
6412  }
6413  }
6414  llvm_unreachable("Invalid TypeCode!");
6415 }
6416 
6417 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6418  SmallVectorImpl<QualType> &Exceptions,
6420  const RecordData &Record, unsigned &Idx) {
6422  static_cast<ExceptionSpecificationType>(Record[Idx++]);
6423  ESI.Type = EST;
6424  if (EST == EST_Dynamic) {
6425  for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6426  Exceptions.push_back(readType(ModuleFile, Record, Idx));
6427  ESI.Exceptions = Exceptions;
6428  } else if (isComputedNoexcept(EST)) {
6429  ESI.NoexceptExpr = ReadExpr(ModuleFile);
6430  } else if (EST == EST_Uninstantiated) {
6431  ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6432  ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6433  } else if (EST == EST_Unevaluated) {
6434  ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6435  }
6436 }
6437 
6438 namespace clang {
6439 
6440 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6441  ModuleFile *F;
6442  ASTReader *Reader;
6443  const ASTReader::RecordData &Record;
6444  unsigned &Idx;
6445 
6446  SourceLocation ReadSourceLocation() {
6447  return Reader->ReadSourceLocation(*F, Record, Idx);
6448  }
6449 
6450  TypeSourceInfo *GetTypeSourceInfo() {
6451  return Reader->GetTypeSourceInfo(*F, Record, Idx);
6452  }
6453 
6454  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6455  return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6456  }
6457 
6458 public:
6459  TypeLocReader(ModuleFile &F, ASTReader &Reader,
6460  const ASTReader::RecordData &Record, unsigned &Idx)
6461  : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6462 
6463  // We want compile-time assurance that we've enumerated all of
6464  // these, so unfortunately we have to declare them first, then
6465  // define them out-of-line.
6466 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6467 #define TYPELOC(CLASS, PARENT) \
6468  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6469 #include "clang/AST/TypeLocNodes.def"
6470 
6471  void VisitFunctionTypeLoc(FunctionTypeLoc);
6472  void VisitArrayTypeLoc(ArrayTypeLoc);
6473 };
6474 
6475 } // namespace clang
6476 
6477 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6478  // nothing to do
6479 }
6480 
6481 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6482  TL.setBuiltinLoc(ReadSourceLocation());
6483  if (TL.needsExtraLocalData()) {
6484  TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6485  TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6486  TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6487  TL.setModeAttr(Record[Idx++]);
6488  }
6489 }
6490 
6491 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6492  TL.setNameLoc(ReadSourceLocation());
6493 }
6494 
6495 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6496  TL.setStarLoc(ReadSourceLocation());
6497 }
6498 
6499 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6500  // nothing to do
6501 }
6502 
6503 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6504  // nothing to do
6505 }
6506 
6507 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6508  TL.setCaretLoc(ReadSourceLocation());
6509 }
6510 
6511 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6512  TL.setAmpLoc(ReadSourceLocation());
6513 }
6514 
6515 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6516  TL.setAmpAmpLoc(ReadSourceLocation());
6517 }
6518 
6519 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6520  TL.setStarLoc(ReadSourceLocation());
6521  TL.setClassTInfo(GetTypeSourceInfo());
6522 }
6523 
6525  TL.setLBracketLoc(ReadSourceLocation());
6526  TL.setRBracketLoc(ReadSourceLocation());
6527  if (Record[Idx++])
6528  TL.setSizeExpr(Reader->ReadExpr(*F));
6529  else
6530  TL.setSizeExpr(nullptr);
6531 }
6532 
6533 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6534  VisitArrayTypeLoc(TL);
6535 }
6536 
6537 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6538  VisitArrayTypeLoc(TL);
6539 }
6540 
6541 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6542  VisitArrayTypeLoc(TL);
6543 }
6544 
6545 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6547  VisitArrayTypeLoc(TL);
6548 }
6549 
6550 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6552 
6553  TL.setAttrNameLoc(ReadSourceLocation());
6554  SourceRange range;
6555  range.setBegin(ReadSourceLocation());
6556  range.setEnd(ReadSourceLocation());
6557  TL.setAttrOperandParensRange(range);
6558  TL.setAttrExprOperand(Reader->ReadExpr(*F));
6559 }
6560 
6561 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6563  TL.setNameLoc(ReadSourceLocation());
6564 }
6565 
6566 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6567  TL.setNameLoc(ReadSourceLocation());
6568 }
6569 
6570 void TypeLocReader::VisitDependentVectorTypeLoc(
6572  TL.setNameLoc(ReadSourceLocation());
6573 }
6574 
6575 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6576  TL.setNameLoc(ReadSourceLocation());
6577 }
6578 
6580  TL.setLocalRangeBegin(ReadSourceLocation());
6581  TL.setLParenLoc(ReadSourceLocation());
6582  TL.setRParenLoc(ReadSourceLocation());
6583  TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6584  Reader->ReadSourceLocation(*F, Record, Idx)));
6585  TL.setLocalRangeEnd(ReadSourceLocation());
6586  for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6587  TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6588  }
6589 }
6590 
6591 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6592  VisitFunctionTypeLoc(TL);
6593 }
6594 
6595 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6596  VisitFunctionTypeLoc(TL);
6597 }
6598 
6599 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6600  TL.setNameLoc(ReadSourceLocation());
6601 }
6602 
6603 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6604  TL.setNameLoc(ReadSourceLocation());
6605 }
6606 
6607 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6608  TL.setTypeofLoc(ReadSourceLocation());
6609  TL.setLParenLoc(ReadSourceLocation());
6610  TL.setRParenLoc(ReadSourceLocation());
6611 }
6612 
6613 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6614  TL.setTypeofLoc(ReadSourceLocation());
6615  TL.setLParenLoc(ReadSourceLocation());
6616  TL.setRParenLoc(ReadSourceLocation());
6617  TL.setUnderlyingTInfo(GetTypeSourceInfo());
6618 }
6619 
6620 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6621  TL.setNameLoc(ReadSourceLocation());
6622 }
6623 
6624 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6625  TL.setKWLoc(ReadSourceLocation());
6626  TL.setLParenLoc(ReadSourceLocation());
6627  TL.setRParenLoc(ReadSourceLocation());
6628  TL.setUnderlyingTInfo(GetTypeSourceInfo());
6629 }
6630 
6631 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6632  TL.setNameLoc(ReadSourceLocation());
6633 }
6634 
6635 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6637  TL.setTemplateNameLoc(ReadSourceLocation());
6638 }
6639 
6640 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6641  TL.setNameLoc(ReadSourceLocation());
6642 }
6643 
6644 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6645  TL.setNameLoc(ReadSourceLocation());
6646 }
6647 
6648 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6649  TL.setAttrNameLoc(ReadSourceLocation());
6650  if (TL.hasAttrOperand()) {
6651  SourceRange range;
6652  range.setBegin(ReadSourceLocation());
6653  range.setEnd(ReadSourceLocation());
6654  TL.setAttrOperandParensRange(range);
6655  }
6656  if (TL.hasAttrExprOperand()) {
6657  if (Record[Idx++])
6658  TL.setAttrExprOperand(Reader->ReadExpr(*F));
6659  else
6660  TL.setAttrExprOperand(nullptr);
6661  } else if (TL.hasAttrEnumOperand())
6662  TL.setAttrEnumOperandLoc(ReadSourceLocation());
6663 }
6664 
6665 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6666  TL.setNameLoc(ReadSourceLocation());
6667 }
6668 
6669 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6671  TL.setNameLoc(ReadSourceLocation());
6672 }
6673 
6674 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6676  TL.setNameLoc(ReadSourceLocation());
6677 }
6678 
6679 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6681  TL.setTemplateKeywordLoc(ReadSourceLocation());
6682  TL.setTemplateNameLoc(ReadSourceLocation());
6683  TL.setLAngleLoc(ReadSourceLocation());
6684  TL.setRAngleLoc(ReadSourceLocation());
6685  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6686  TL.setArgLocInfo(
6687  i,
6688  Reader->GetTemplateArgumentLocInfo(
6689  *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6690 }
6691 
6692 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6693  TL.setLParenLoc(ReadSourceLocation());
6694  TL.setRParenLoc(ReadSourceLocation());
6695 }
6696 
6697 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6698  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6699  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6700 }
6701 
6702 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6703  TL.setNameLoc(ReadSourceLocation());
6704 }
6705 
6706 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6707  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6708  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6709  TL.setNameLoc(ReadSourceLocation());
6710 }
6711 
6712 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6714  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6715  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6716  TL.setTemplateKeywordLoc(ReadSourceLocation());
6717  TL.setTemplateNameLoc(ReadSourceLocation());
6718  TL.setLAngleLoc(ReadSourceLocation());
6719  TL.setRAngleLoc(ReadSourceLocation());
6720  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6721  TL.setArgLocInfo(
6722  I,
6723  Reader->GetTemplateArgumentLocInfo(
6724  *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6725 }
6726 
6727 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6728  TL.setEllipsisLoc(ReadSourceLocation());
6729 }
6730 
6731 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6732  TL.setNameLoc(ReadSourceLocation());
6733 }
6734 
6735 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6736  if (TL.getNumProtocols()) {
6737  TL.setProtocolLAngleLoc(ReadSourceLocation());
6738  TL.setProtocolRAngleLoc(ReadSourceLocation());
6739  }
6740  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6741  TL.setProtocolLoc(i, ReadSourceLocation());
6742 }
6743 
6744 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6745  TL.setHasBaseTypeAsWritten(Record[Idx++]);
6746  TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6747  TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6748  for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6749  TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6750  TL.setProtocolLAngleLoc(ReadSourceLocation());
6751  TL.setProtocolRAngleLoc(ReadSourceLocation());
6752  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6753  TL.setProtocolLoc(i, ReadSourceLocation());
6754 }
6755 
6756 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6757  TL.setStarLoc(ReadSourceLocation());
6758 }
6759 
6760 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6761  TL.setKWLoc(ReadSourceLocation());
6762  TL.setLParenLoc(ReadSourceLocation());
6763  TL.setRParenLoc(ReadSourceLocation());
6764 }
6765 
6766 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6767  TL.setKWLoc(ReadSourceLocation());
6768 }
6769 
6770 void ASTReader::ReadTypeLoc(ModuleFile &F, const ASTReader::RecordData &Record,
6771  unsigned &Idx, TypeLoc TL) {
6772  TypeLocReader TLR(F, *this, Record, Idx);
6773  for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6774  TLR.Visit(TL);
6775 }
6776 
6779  unsigned &Idx) {
6780  QualType InfoTy = readType(F, Record, Idx);
6781  if (InfoTy.isNull())
6782  return nullptr;
6783 
6784  TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6785  ReadTypeLoc(F, Record, Idx, TInfo->getTypeLoc());
6786  return TInfo;
6787 }
6788 
6790  assert(ContextObj && "reading type with no AST context");
6791  ASTContext &Context = *ContextObj;
6792 
6793  unsigned FastQuals = ID & Qualifiers::FastMask;
6794  unsigned Index = ID >> Qualifiers::FastWidth;
6795 
6796  if (Index < NUM_PREDEF_TYPE_IDS) {
6797  QualType T;
6798  switch ((PredefinedTypeIDs)Index) {
6799  case PREDEF_TYPE_NULL_ID:
6800  return QualType();
6801  case PREDEF_TYPE_VOID_ID:
6802  T = Context.VoidTy;
6803  break;
6804  case PREDEF_TYPE_BOOL_ID:
6805  T = Context.BoolTy;
6806  break;
6807  case PREDEF_TYPE_CHAR_U_ID:
6808  case PREDEF_TYPE_CHAR_S_ID:
6809  // FIXME: Check that the signedness of CharTy is correct!
6810  T = Context.CharTy;
6811  break;
6812  case PREDEF_TYPE_UCHAR_ID:
6813  T = Context.UnsignedCharTy;
6814  break;
6815  case PREDEF_TYPE_USHORT_ID:
6816  T = Context.UnsignedShortTy;
6817  break;
6818  case PREDEF_TYPE_UINT_ID:
6819  T = Context.UnsignedIntTy;
6820  break;
6821  case PREDEF_TYPE_ULONG_ID:
6822  T = Context.UnsignedLongTy;
6823  break;
6825  T = Context.UnsignedLongLongTy;
6826  break;
6828  T = Context.UnsignedInt128Ty;
6829  break;
6830  case PREDEF_TYPE_SCHAR_ID:
6831  T = Context.SignedCharTy;
6832  break;
6833  case PREDEF_TYPE_WCHAR_ID:
6834  T = Context.WCharTy;
6835  break;
6836  case PREDEF_TYPE_SHORT_ID:
6837  T = Context.ShortTy;
6838  break;
6839  case PREDEF_TYPE_INT_ID:
6840  T = Context.IntTy;
6841  break;
6842  case PREDEF_TYPE_LONG_ID:
6843  T = Context.LongTy;
6844  break;
6846  T = Context.LongLongTy;
6847  break;
6848  case PREDEF_TYPE_INT128_ID:
6849  T = Context.Int128Ty;
6850  break;
6851  case PREDEF_TYPE_HALF_ID:
6852  T = Context.HalfTy;
6853  break;
6854  case PREDEF_TYPE_FLOAT_ID:
6855  T = Context.FloatTy;
6856  break;
6857  case PREDEF_TYPE_DOUBLE_ID:
6858  T = Context.DoubleTy;
6859  break;
6861  T = Context.LongDoubleTy;
6862  break;
6864  T = Context.ShortAccumTy;
6865  break;
6866  case PREDEF_TYPE_ACCUM_ID:
6867  T = Context.AccumTy;
6868  break;
6870  T = Context.LongAccumTy;
6871  break;
6873  T = Context.UnsignedShortAccumTy;
6874  break;
6875  case PREDEF_TYPE_UACCUM_ID:
6876  T = Context.UnsignedAccumTy;
6877  break;
6879  T = Context.UnsignedLongAccumTy;
6880  break;
6882  T = Context.ShortFractTy;
6883  break;
6884  case PREDEF_TYPE_FRACT_ID:
6885  T = Context.FractTy;
6886  break;
6888  T = Context.LongFractTy;
6889  break;
6891  T = Context.UnsignedShortFractTy;
6892  break;
6893  case PREDEF_TYPE_UFRACT_ID:
6894  T = Context.UnsignedFractTy;
6895  break;
6897  T = Context.UnsignedLongFractTy;
6898  break;
6900  T = Context.SatShortAccumTy;
6901  break;
6903  T = Context.SatAccumTy;
6904  break;
6906  T = Context.SatLongAccumTy;
6907  break;
6909  T = Context.SatUnsignedShortAccumTy;
6910  break;
6912  T = Context.SatUnsignedAccumTy;
6913  break;
6915  T = Context.SatUnsignedLongAccumTy;
6916  break;
6918  T = Context.SatShortFractTy;
6919  break;
6921  T = Context.SatFractTy;
6922  break;
6924  T = Context.SatLongFractTy;
6925  break;
6927  T = Context.SatUnsignedShortFractTy;
6928  break;
6930  T = Context.SatUnsignedFractTy;
6931  break;
6933  T = Context.SatUnsignedLongFractTy;
6934  break;
6936  T = Context.Float16Ty;
6937  break;
6939  T = Context.Float128Ty;
6940  break;
6942  T = Context.OverloadTy;
6943  break;
6945  T = Context.BoundMemberTy;
6946  break;
6948  T = Context.PseudoObjectTy;
6949  break;
6951  T = Context.DependentTy;
6952  break;
6954  T = Context.UnknownAnyTy;
6955  break;
6957  T = Context.NullPtrTy;
6958  break;
6959  case PREDEF_TYPE_CHAR8_ID:
6960  T = Context.Char8Ty;
6961  break;
6962  case PREDEF_TYPE_CHAR16_ID:
6963  T = Context.Char16Ty;
6964  break;
6965  case PREDEF_TYPE_CHAR32_ID:
6966  T = Context.Char32Ty;
6967  break;
6968  case PREDEF_TYPE_OBJC_ID:
6969  T = Context.ObjCBuiltinIdTy;
6970  break;
6972  T = Context.ObjCBuiltinClassTy;
6973  break;
6974  case PREDEF_TYPE_OBJC_SEL:
6975  T = Context.ObjCBuiltinSelTy;
6976  break;
6977 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6978  case PREDEF_TYPE_##Id##_ID: \
6979  T = Context.SingletonId; \
6980  break;
6981 #include "clang/Basic/OpenCLImageTypes.def"
6983  T = Context.OCLSamplerTy;
6984  break;
6985  case PREDEF_TYPE_EVENT_ID:
6986  T = Context.OCLEventTy;
6987  break;
6989  T = Context.OCLClkEventTy;
6990  break;
6991  case PREDEF_TYPE_QUEUE_ID:
6992  T = Context.OCLQueueTy;
6993  break;
6995  T = Context.OCLReserveIDTy;
6996  break;
6998  T = Context.getAutoDeductType();
6999  break;
7001  T = Context.getAutoRRefDeductType();
7002  break;
7004  T = Context.ARCUnbridgedCastTy;
7005  break;
7007  T = Context.BuiltinFnTy;
7008  break;
7010  T = Context.OMPArraySectionTy;
7011  break;
7012  }
7013 
7014  assert(!T.isNull() && "Unknown predefined type");
7015  return T.withFastQualifiers(FastQuals);
7016  }
7017 
7018  Index -= NUM_PREDEF_TYPE_IDS;
7019  assert(Index < TypesLoaded.size() && "Type index out-of-range");
7020  if (TypesLoaded[Index].isNull()) {
7021  TypesLoaded[Index] = readTypeRecord(Index);
7022  if (TypesLoaded[Index].isNull())
7023  return QualType();
7024 
7025  TypesLoaded[Index]->setFromAST();
7026  if (DeserializationListener)
7027  DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7028  TypesLoaded[Index]);
7029  }
7030 
7031  return TypesLoaded[Index].withFastQualifiers(FastQuals);
7032 }
7033 
7034 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7035  return GetType(getGlobalTypeID(F, LocalID));
7036 }
7037 
7039 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7040  unsigned FastQuals = LocalID & Qualifiers::FastMask;
7041  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7042 
7043  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7044  return LocalID;
7045 
7046  if (!F.ModuleOffsetMap.empty())
7047  ReadModuleOffsetMap(F);
7048 
7050  = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7051  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7052 
7053  unsigned GlobalIndex = LocalIndex + I->second;
7054  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7055 }
7056 
7060  const RecordData &Record,
7061  unsigned &Index) {
7062  switch (Kind) {
7064  return ReadExpr(F);
7066  return GetTypeSourceInfo(F, Record, Index);
7068  NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7069  Index);
7070  SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7071  return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7072  SourceLocation());
7073  }
7075  NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7076  Index);
7077  SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7078  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
7079  return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7080  EllipsisLoc);
7081  }
7087  // FIXME: Is this right?
7088  return TemplateArgumentLocInfo();
7089  }
7090  llvm_unreachable("unexpected template argument loc");
7091 }
7092 
7095  const RecordData &Record, unsigned &Index) {
7096  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
7097 
7098  if (Arg.getKind() == TemplateArgument::Expression) {
7099  if (Record[Index++]) // bool InfoHasSameExpr.
7101  }
7102  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
7103  Record, Index));
7104 }
7105 
7108  const RecordData &Record,
7109  unsigned &Index) {
7110  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
7111  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
7112  unsigned NumArgsAsWritten = Record[Index++];
7113  TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7114  for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7115  TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
7116  return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7117 }
7118 
7120  return GetDecl(ID);
7121 }
7122 
7124  if (NumCurrentElementsDeserializing) {
7125  // We arrange to not care about the complete redeclaration chain while we're
7126  // deserializing. Just remember that the AST has marked this one as complete
7127  // but that it's not actually complete yet, so we know we still need to
7128  // complete it later.
7129  PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7130  return;
7131  }
7132 
7133  const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7134 
7135  // If this is a named declaration, complete it by looking it up
7136  // within its context.
7137  //
7138  // FIXME: Merging a function definition should merge
7139  // all mergeable entities within it.
7140  if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7141  isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7142  if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7143  if (!getContext().getLangOpts().CPlusPlus &&
7144  isa<TranslationUnitDecl>(DC)) {
7145  // Outside of C++, we don't have a lookup table for the TU, so update
7146  // the identifier instead. (For C++ modules, we don't store decls
7147  // in the serialized identifier table, so we do the lookup in the TU.)
7148  auto *II = Name.getAsIdentifierInfo();
7149  assert(II && "non-identifier name in C?");
7150  if (II->isOutOfDate())
7151  updateOutOfDateIdentifier(*II);
7152  } else
7153  DC->lookup(Name);
7154  } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7155  // Find all declarations of this kind from the relevant context.
7156  for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7157  auto *DC = cast<DeclContext>(DCDecl);
7158  SmallVector<Decl*, 8> Decls;
7159  FindExternalLexicalDecls(
7160  DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7161  }
7162  }
7163  }
7164 
7165  if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7166  CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7167  if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7168  VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7169  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7170  if (auto *Template = FD->getPrimaryTemplate())
7171  Template->LoadLazySpecializations();
7172  }
7173 }
7174 
7177  RecordLocation Loc = getLocalBitOffset(Offset);
7178  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7179  SavedStreamPosition SavedPosition(Cursor);
7180  Cursor.JumpToBit(Loc.Offset);
7181  ReadingKindTracker ReadingKind(Read_Decl, *this);
7182 
7183  RecordData Record;
7184  unsigned Code = Cursor.ReadCode();
7185  unsigned RecCode = Cursor.readRecord(Code, Record);
7186  if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
7187  Error("malformed AST file: missing C++ ctor initializers");
7188  return nullptr;
7189  }
7190 
7191  unsigned Idx = 0;
7192  return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
7193 }
7194 
7196  assert(ContextObj && "reading base specifiers with no AST context");
7197  ASTContext &Context = *ContextObj;
7198 
7199  RecordLocation Loc = getLocalBitOffset(Offset);
7200  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7201  SavedStreamPosition SavedPosition(Cursor);
7202  Cursor.JumpToBit(Loc.Offset);
7203  ReadingKindTracker ReadingKind(Read_Decl, *this);
7204  RecordData Record;
7205  unsigned Code = Cursor.ReadCode();
7206  unsigned RecCode = Cursor.readRecord(Code, Record);
7207  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7208  Error("malformed AST file: missing C++ base specifiers");
7209  return nullptr;
7210  }
7211 
7212  unsigned Idx = 0;
7213  unsigned NumBases = Record[Idx++];
7214  void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7215  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7216  for (unsigned I = 0; I != NumBases; ++I)
7217  Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
7218  return Bases;
7219 }
7220 
7222 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7223  if (LocalID < NUM_PREDEF_DECL_IDS)
7224  return LocalID;
7225 
7226  if (!F.ModuleOffsetMap.empty())
7227  ReadModuleOffsetMap(F);
7228 
7230  = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7231  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7232 
7233  return LocalID + I->second;
7234 }
7235 
7237  ModuleFile &M) const {
7238  // Predefined decls aren't from any module.
7239  if (ID < NUM_PREDEF_DECL_IDS)
7240  return false;
7241 
7242  return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7243  ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7244 }
7245 
7246 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7247  if (!D->isFromASTFile())
7248  return nullptr;
7249  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7250  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7251  return I->second;
7252 }
7253 
7255  if (ID < NUM_PREDEF_DECL_IDS)
7256  return SourceLocation();
7257 
7258  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7259 
7260  if (Index > DeclsLoaded.size()) {
7261  Error("declaration ID out-of-range for AST file");
7262  return SourceLocation();
7263  }
7264 
7265  if (Decl *D = DeclsLoaded[Index])
7266  return D->getLocation();
7267 
7268  SourceLocation Loc;
7269  DeclCursorForID(ID, Loc);
7270  return Loc;
7271 }
7272 
7274  switch (ID) {
7275  case PREDEF_DECL_NULL_ID:
7276  return nullptr;
7277 
7279  return Context.getTranslationUnitDecl();
7280 
7282  return Context.getObjCIdDecl();
7283 
7285  return Context.getObjCSelDecl();
7286 
7288  return Context.getObjCClassDecl();
7289 
7291  return Context.getObjCProtocolDecl();
7292 
7294  return Context.getInt128Decl();
7295 
7297  return Context.getUInt128Decl();
7298 
7300  return Context.getObjCInstanceTypeDecl();
7301 
7303  return Context.getBuiltinVaListDecl();
7304 
7306  return Context.getVaListTagDecl();
7307 
7309  return Context.getBuiltinMSVaListDecl();
7310 
7312  return Context.getExternCContextDecl();
7313 
7315  return Context.getMakeIntegerSeqDecl();
7316 
7318  return Context.getCFConstantStringDecl();
7319 
7321  return Context.getCFConstantStringTagDecl();
7322 
7324  return Context.getTypePackElementDecl();
7325  }
7326  llvm_unreachable("PredefinedDeclIDs unknown enum value");
7327 }
7328 
7330  assert(ContextObj && "reading decl with no AST context");
7331  if (ID < NUM_PREDEF_DECL_IDS) {
7332  Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7333  if (D) {
7334  // Track that we have merged the declaration with ID \p ID into the
7335  // pre-existing predefined declaration \p D.
7336  auto &Merged = KeyDecls[D->getCanonicalDecl()];
7337  if (Merged.empty())
7338  Merged.push_back(ID);
7339  }
7340  return D;
7341  }
7342 
7343  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7344 
7345  if (Index >= DeclsLoaded.size()) {
7346  assert(0 && "declaration ID out-of-range for AST file");
7347  Error("declaration ID out-of-range for AST file");
7348  return nullptr;
7349  }
7350 
7351  return DeclsLoaded[Index];
7352 }
7353 
7355  if (ID < NUM_PREDEF_DECL_IDS)
7356  return GetExistingDecl(ID);
7357 
7358  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7359 
7360  if (Index >= DeclsLoaded.size()) {
7361  assert(0 && "declaration ID out-of-range for AST file");
7362  Error("declaration ID out-of-range for AST file");
7363  return nullptr;
7364  }
7365 
7366  if (!DeclsLoaded[Index]) {
7367  ReadDeclRecord(ID);
7368  if (DeserializationListener)
7369  DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7370  }
7371 
7372  return DeclsLoaded[Index];
7373 }
7374 
7376  DeclID GlobalID) {
7377  if (GlobalID < NUM_PREDEF_DECL_IDS)
7378  return GlobalID;
7379 
7380  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7381  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7382  ModuleFile *Owner = I->second;
7383 
7384  llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7385  = M.GlobalToLocalDeclIDs.find(Owner);
7386  if (Pos == M.GlobalToLocalDeclIDs.end())
7387  return 0;
7388 
7389  return GlobalID - Owner->BaseDeclID + Pos->second;
7390 }
7391 
7393  const RecordData &Record,
7394  unsigned &Idx) {
7395  if (Idx >= Record.size()) {
7396  Error("Corrupted AST file");
7397  return 0;
7398  }
7399 
7400  return getGlobalDeclID(F, Record[Idx++]);
7401 }
7402 
7403 /// Resolve the offset of a statement into a statement.
7404 ///
7405 /// This operation will read a new statement from the external
7406 /// source each time it is called, and is meant to be used via a
7407 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7409  // Switch case IDs are per Decl.
7410  ClearSwitchCaseIDs();
7411 
7412  // Offset here is a global offset across the entire chain.
7413  RecordLocation Loc = getLocalBitOffset(Offset);
7414  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7415  assert(NumCurrentElementsDeserializing == 0 &&
7416  "should not be called while already deserializing");
7417  Deserializing D(this);
7418  return ReadStmtFromStream(*Loc.F);
7419 }
7420 
7422  const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7423  SmallVectorImpl<Decl *> &Decls) {
7424  bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7425 
7426  auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7427  assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7428  for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7429  auto K = (Decl::Kind)+LexicalDecls[I];
7430  if (!IsKindWeWant(K))
7431  continue;
7432 
7433  auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7434 
7435  // Don't add predefined declarations to the lexical context more
7436  // than once.
7437  if (ID < NUM_PREDEF_DECL_IDS) {
7438  if (PredefsVisited[ID])
7439  continue;
7440 
7441  PredefsVisited[ID] = true;
7442  }
7443 
7444  if (Decl *D = GetLocalDecl(*M, ID)) {
7445  assert(D->getKind() == K && "wrong kind for lexical decl");
7446  if (!DC->isDeclInLexicalTraversal(D))
7447  Decls.push_back(D);
7448  }
7449  }
7450  };
7451 
7452  if (isa<TranslationUnitDecl>(DC)) {
7453  for (auto Lexical : TULexicalDecls)
7454  Visit(Lexical.first, Lexical.second);
7455  } else {
7456  auto I = LexicalDecls.find(DC);
7457  if (I != LexicalDecls.end())
7458  Visit(I->second.first, I->second.second);
7459  }
7460 
7461  ++NumLexicalDeclContextsRead;
7462 }
7463 
7464 namespace {
7465 
7466 class DeclIDComp {
7467  ASTReader &Reader;
7468  ModuleFile &Mod;
7469 
7470 public:
7471  DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7472 
7473  bool operator()(LocalDeclID L, LocalDeclID R) const {
7474  SourceLocation LHS = getLocation(L);
7475  SourceLocation RHS = getLocation(R);
7476  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7477  }
7478 
7479  bool operator()(SourceLocation LHS, LocalDeclID R) const {
7480  SourceLocation RHS = getLocation(R);
7481  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7482  }
7483 
7484  bool operator()(LocalDeclID L, SourceLocation RHS) const {
7485  SourceLocation LHS = getLocation(L);
7486  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7487  }
7488 
7489  SourceLocation getLocation(LocalDeclID ID) const {
7490  return Reader.getSourceManager().getFileLoc(
7491  Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7492  }
7493 };
7494 
7495 } // namespace
7496 
7498  unsigned Offset, unsigned Length,
7499  SmallVectorImpl<Decl *> &Decls) {
7500  SourceManager &SM = getSourceManager();
7501 
7502  llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7503  if (I == FileDeclIDs.end())
7504  return;
7505 
7506  FileDeclsInfo &DInfo = I->second;
7507  if (DInfo.Decls.empty())
7508  return;
7509 
7511  BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7512  SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7513 
7514  DeclIDComp DIDComp(*this, *DInfo.Mod);
7516  BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7517  BeginLoc, DIDComp);
7518  if (BeginIt != DInfo.Decls.begin())
7519  --BeginIt;
7520 
7521  // If we are pointing at a top-level decl inside an objc container, we need
7522  // to backtrack until we find it otherwise we will fail to report that the
7523  // region overlaps with an objc container.
7524  while (BeginIt != DInfo.Decls.begin() &&
7525  GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7526  ->isTopLevelDeclInObjCContainer())
7527  --BeginIt;
7528 
7530  EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7531  EndLoc, DIDComp);
7532  if (EndIt != DInfo.Decls.end())
7533  ++EndIt;
7534 
7536  DIt = BeginIt; DIt != EndIt; ++DIt)
7537  Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7538 }
7539 
7540 bool
7542  DeclarationName Name) {
7543  assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7544  "DeclContext has no visible decls in storage");
7545  if (!Name)
7546  return false;
7547 
7548  auto It = Lookups.find(DC);
7549  if (It == Lookups.end())
7550  return false;
7551 
7552  Deserializing LookupResults(this);
7553 
7554  // Load the list of declarations.
7556  for (DeclID ID : It->second.Table.find(Name)) {
7557  NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7558  if (ND->getDeclName() == Name)
7559  Decls.push_back(ND);
7560  }
7561 
7562  ++NumVisibleDeclContextsRead;
7563  SetExternalVisibleDeclsForName(DC, Name, Decls);
7564  return !Decls.empty();
7565 }
7566 
7568  if (!DC->hasExternalVisibleStorage())
7569  return;
7570 
7571  auto It = Lookups.find(DC);
7572  assert(It != Lookups.end() &&
7573  "have external visible storage but no lookup tables");
7574 
7575  DeclsMap Decls;
7576 
7577  for (DeclID ID : It->second.Table.findAll()) {
7578  NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7579  Decls[ND->getDeclName()].push_back(ND);
7580  }
7581 
7582  ++NumVisibleDeclContextsRead;
7583 
7584  for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7585  SetExternalVisibleDeclsForName(DC, I->first, I->second);
7586  }
7587  const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7588 }
7589 
7592  auto I = Lookups.find(Primary);
7593  return I == Lookups.end() ? nullptr : &I->second;
7594 }
7595 
7596 /// Under non-PCH compilation the consumer receives the objc methods
7597 /// before receiving the implementation, and codegen depends on this.
7598 /// We simulate this by deserializing and passing to consumer the methods of the
7599 /// implementation before passing the deserialized implementation decl.
7601  ASTConsumer *Consumer) {
7602  assert(ImplD && Consumer);
7603 
7604  for (auto *I : ImplD->methods())
7605  Consumer->HandleInterestingDecl(DeclGroupRef(I));
7606 
7607  Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7608 }
7609 
7610 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7611  if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7612  PassObjCImplDeclToConsumer(ImplD, Consumer);
7613  else
7614  Consumer->HandleInterestingDecl(DeclGroupRef(D));
7615 }
7616 
7618  this->Consumer = Consumer;
7619 
7620  if (Consumer)
7621  PassInterestingDeclsToConsumer();
7622 
7623  if (DeserializationListener)
7624  DeserializationListener->ReaderInitialized(this);
7625 }
7626 
7628  std::fprintf(stderr, "*** AST File Statistics:\n");
7629 
7630  unsigned NumTypesLoaded
7631  = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7632  QualType());
7633  unsigned NumDeclsLoaded
7634  = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7635  (Decl *)nullptr);
7636  unsigned NumIdentifiersLoaded
7637  = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7638  IdentifiersLoaded.end(),
7639  (IdentifierInfo *)nullptr);
7640  unsigned NumMacrosLoaded
7641  = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7642  MacrosLoaded.end(),
7643  (MacroInfo *)nullptr);
7644  unsigned NumSelectorsLoaded
7645  = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7646  SelectorsLoaded.end(),
7647  Selector());
7648 
7649  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7650  std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7651  NumSLocEntriesRead, TotalNumSLocEntries,
7652  ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7653  if (!TypesLoaded.empty())
7654  std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7655  NumTypesLoaded, (unsigned)TypesLoaded.size(),
7656  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7657  if (!DeclsLoaded.empty())
7658  std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7659  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7660  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7661  if (!IdentifiersLoaded.empty())
7662  std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7663  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7664  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7665  if (!MacrosLoaded.empty())
7666  std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7667  NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7668  ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7669  if (!SelectorsLoaded.empty())
7670  std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7671  NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7672  ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7673  if (TotalNumStatements)
7674  std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7675  NumStatementsRead, TotalNumStatements,
7676  ((float)NumStatementsRead/TotalNumStatements * 100));
7677  if (TotalNumMacros)
7678  std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7679  NumMacrosRead, TotalNumMacros,
7680  ((float)NumMacrosRead/TotalNumMacros * 100));
7681  if (TotalLexicalDeclContexts)
7682  std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7683  NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7684  ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7685  * 100));
7686  if (TotalVisibleDeclContexts)
7687  std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7688  NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7689  ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7690  * 100));
7691  if (TotalNumMethodPoolEntries)
7692  std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7693  NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7694  ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7695  * 100));
7696  if (NumMethodPoolLookups)
7697  std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7698  NumMethodPoolHits, NumMethodPoolLookups,
7699  ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7700  if (NumMethodPoolTableLookups)
7701  std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7702  NumMethodPoolTableHits, NumMethodPoolTableLookups,
7703  ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7704  * 100.0));
7705  if (NumIdentifierLookupHits)
7706  std::fprintf(stderr,
7707  " %u / %u identifier table lookups succeeded (%f%%)\n",
7708  NumIdentifierLookupHits, NumIdentifierLookups,
7709  (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7710 
7711  if (GlobalIndex) {
7712  std::fprintf(stderr, "\n");
7713  GlobalIndex->printStats();
7714  }
7715 
7716  std::fprintf(stderr, "\n");
7717  dump();
7718  std::fprintf(stderr, "\n");
7719 }
7720 
7721 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7722 LLVM_DUMP_METHOD static void
7723 dumpModuleIDMap(StringRef Name,
7724  const ContinuousRangeMap<Key, ModuleFile *,
7725  InitialCapacity> &Map) {
7726  if (Map.begin() == Map.end())
7727  return;
7728 
7730 
7731  llvm::errs() << Name << ":\n";
7732  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7733  I != IEnd; ++I) {
7734  llvm::errs() << " " << I->first << " -> " << I->second->FileName
7735  << "\n";
7736  }
7737 }
7738 
7739 LLVM_DUMP_METHOD void ASTReader::dump() {
7740  llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7741  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7742  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7743  dumpModuleIDMap("Global type map", GlobalTypeMap);
7744  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7745  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7746  dumpModuleIDMap("Global macro map", GlobalMacroMap);
7747  dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7748  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7749  dumpModuleIDMap("Global preprocessed entity map",
7750  GlobalPreprocessedEntityMap);
7751 
7752  llvm::errs() << "\n*** PCH/Modules Loaded:";
7753  for (ModuleFile &M : ModuleMgr)
7754  M.dump();
7755 }
7756 
7757 /// Return the amount of memory used by memory buffers, breaking down
7758 /// by heap-backed versus mmap'ed memory.
7760  for (ModuleFile &I : ModuleMgr) {
7761  if (llvm::MemoryBuffer *buf = I.Buffer) {
7762  size_t bytes = buf->getBufferSize();
7763  switch (buf->getBufferKind()) {
7764  case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7765  sizes.malloc_bytes += bytes;
7766  break;
7767  case llvm::MemoryBuffer::MemoryBuffer_MMap:
7768  sizes.mmap_bytes += bytes;
7769  break;
7770  }
7771  }
7772  }
7773 }
7774 
7776  SemaObj = &S;
7777  S.addExternalSource(this);
7778 
7779  // Makes sure any declarations that were deserialized "too early"
7780  // still get added to the identifier's declaration chains.
7781  for (uint64_t ID : PreloadedDeclIDs) {
7782  NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7783  pushExternalDeclIntoScope(D, D->getDeclName());
7784  }
7785  PreloadedDeclIDs.clear();
7786 
7787  // FIXME: What happens if these are changed by a module import?
7788  if (!FPPragmaOptions.empty()) {
7789  assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7790  SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7791  }
7792 
7793  SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7794  SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7795  SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7796 
7797  UpdateSema();
7798 }
7799 
7801  assert(SemaObj && "no Sema to update");
7802 
7803  // Load the offsets of the declarations that Sema references.
7804  // They will be lazily deserialized when needed.
7805  if (!SemaDeclRefs.empty()) {
7806  assert(SemaDeclRefs.size() % 3 == 0);
7807  for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7808  if (!SemaObj->StdNamespace)
7809  SemaObj->StdNamespace = SemaDeclRefs[I];
7810  if (!SemaObj->StdBadAlloc)
7811  SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7812  if (!SemaObj->StdAlignValT)
7813  SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7814  }
7815  SemaDeclRefs.clear();
7816  }
7817 
7818  // Update the state of pragmas. Use the same API as if we had encountered the
7819  // pragma in the source.
7820  if(OptimizeOffPragmaLocation.isValid())
7821  SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7822  if (PragmaMSStructState != -1)
7823  SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7824  if (PointersToMembersPragmaLocation.isValid()) {
7825  SemaObj->ActOnPragmaMSPointersToMembers(
7827  PragmaMSPointersToMembersState,
7828  PointersToMembersPragmaLocation);
7829  }
7830  SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7831 
7832  if (PragmaPackCurrentValue) {
7833  // The bottom of the stack might have a default value. It must be adjusted
7834  // to the current value to ensure that the packing state is preserved after
7835  // popping entries that were included/imported from a PCH/module.
7836  bool DropFirst = false;
7837  if (!PragmaPackStack.empty() &&
7838  PragmaPackStack.front().Location.isInvalid()) {
7839  assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7840  "Expected a default alignment value");
7841  SemaObj->PackStack.Stack.emplace_back(
7842  PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7843  SemaObj->PackStack.CurrentPragmaLocation,
7844  PragmaPackStack.front().PushLocation);
7845  DropFirst = true;
7846  }
7847  for (const auto &Entry :
7848  llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7849  SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7850  Entry.Location, Entry.PushLocation);
7851  if (PragmaPackCurrentLocation.isInvalid()) {
7852  assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7853  "Expected a default alignment value");
7854  // Keep the current values.
7855  } else {
7856  SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7857  SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7858  }
7859  }
7860 }
7861 
7862 IdentifierInfo *ASTReader::get(StringRef Name) {
7863  // Note that we are loading an identifier.
7864  Deserializing AnIdentifier(this);
7865 
7866  IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7867  NumIdentifierLookups,
7868  NumIdentifierLookupHits);
7869 
7870  // We don't need to do identifier table lookups in C++ modules (we preload
7871  // all interesting declarations, and don't need to use the scope for name
7872  // lookups). Perform the lookup in PCH files, though, since we don't build
7873  // a complete initial identifier table if we're carrying on from a PCH.
7874  if (PP.getLangOpts().CPlusPlus) {
7875  for (auto F : ModuleMgr.pch_modules())
7876  if (Visitor(*F))
7877  break;
7878  } else {
7879  // If there is a global index, look there first to determine which modules
7880  // provably do not have any results for this identifier.
7882  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7883  if (!loadGlobalIndex()) {
7884  if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7885  HitsPtr = &Hits;
7886  }
7887  }
7888 
7889  ModuleMgr.visit(Visitor, HitsPtr);
7890  }
7891 
7892  IdentifierInfo *II = Visitor.getIdentifierInfo();
7893  markIdentifierUpToDate(II);
7894  return II;
7895 }
7896 
7897 namespace clang {
7898 
7899  /// An identifier-lookup iterator that enumerates all of the
7900  /// identifiers stored within a set of AST files.
7902  /// The AST reader whose identifiers are being enumerated.
7903  const ASTReader &Reader;
7904 
7905  /// The current index into the chain of AST files stored in
7906  /// the AST reader.
7907  unsigned Index;
7908 
7909  /// The current position within the identifier lookup table
7910  /// of the current AST file.
7911  ASTIdentifierLookupTable::key_iterator Current;
7912 
7913  /// The end position within the identifier lookup table of
7914  /// the current AST file.
7915  ASTIdentifierLookupTable::key_iterator End;
7916 
7917  /// Whether to skip any modules in the ASTReader.
7918  bool SkipModules;
7919 
7920  public:
7921  explicit ASTIdentifierIterator(const ASTReader &Reader,
7922  bool SkipModules = false);
7923 
7924  StringRef Next() override;
7925  };
7926 
7927 } // namespace clang
7928 
7930  bool SkipModules)
7931  : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7932 }
7933 
7935  while (Current == End) {
7936  // If we have exhausted all of our AST files, we're done.
7937  if (Index == 0)
7938  return StringRef();
7939 
7940  --Index;
7941  ModuleFile &F = Reader.ModuleMgr[Index];
7942  if (SkipModules && F.isModule())
7943  continue;
7944 
7945  ASTIdentifierLookupTable *IdTable =
7947  Current = IdTable->key_begin();
7948  End = IdTable->key_end();
7949  }
7950 
7951  // We have any identifiers remaining in the current AST file; return
7952  // the next one.
7953  StringRef Result = *Current;
7954  ++Current;
7955  return Result;
7956 }
7957 
7958 namespace {
7959 
7960 /// A utility for appending two IdentifierIterators.
7961 class ChainedIdentifierIterator : public IdentifierIterator {
7962  std::unique_ptr<IdentifierIterator> Current;
7963  std::unique_ptr<IdentifierIterator> Queued;
7964 
7965 public:
7966  ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7967  std::unique_ptr<IdentifierIterator> Second)
7968  : Current(std::move(First)), Queued(std::move(Second)) {}
7969 
7970  StringRef Next() override {
7971  if (!Current)
7972  return StringRef();
7973 
7974  StringRef result = Current->Next();
7975  if (!result.empty())
7976  return result;
7977 
7978  // Try the queued iterator, which may itself be empty.
7979  Current.reset();
7980  std::swap(Current, Queued);
7981  return Next();
7982  }
7983 };
7984 
7985 } // namespace
7986 
7988  if (!loadGlobalIndex()) {
7989  std::unique_ptr<IdentifierIterator> ReaderIter(
7990  new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7991  std::unique_ptr<IdentifierIterator> ModulesIter(
7992  GlobalIndex->createIdentifierIterator());
7993  return new ChainedIdentifierIterator(std::move(ReaderIter),
7994  std::move(ModulesIter));
7995  }
7996 
7997  return new ASTIdentifierIterator(*this);
7998 }
7999 
8000 namespace clang {
8001 namespace serialization {
8002 
8004  ASTReader &Reader;
8005  Selector Sel;
8006  unsigned PriorGeneration;
8007  unsigned InstanceBits = 0;
8008  unsigned FactoryBits = 0;
8009  bool InstanceHasMoreThanOneDecl = false;
8010  bool FactoryHasMoreThanOneDecl = false;
8011  SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8012  SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8013 
8014  public:
8016  unsigned PriorGeneration)
8017  : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8018 
8019  bool operator()(ModuleFile &M) {
8020  if (!M.SelectorLookupTable)
8021  return false;
8022 
8023  // If we've already searched this module file, skip it now.
8024  if (M.Generation <= PriorGeneration)
8025  return true;
8026 
8027  ++Reader.NumMethodPoolTableLookups;
8028  ASTSelectorLookupTable *PoolTable
8030  ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8031  if (Pos == PoolTable->end())
8032  return false;
8033 
8034  ++Reader.NumMethodPoolTableHits;
8035  ++Reader.NumSelectorsRead;
8036  // FIXME: Not quite happy with the statistics here. We probably should
8037  // disable this tracking when called via LoadSelector.
8038  // Also, should entries without methods count as misses?
8039  ++Reader.NumMethodPoolEntriesRead;
8041  if (Reader.DeserializationListener)
8042  Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8043 
8044  InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8045  FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8046  InstanceBits = Data.InstanceBits;
8047  FactoryBits = Data.FactoryBits;
8048  InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8049  FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8050  return true;
8051  }
8052 
8053  /// Retrieve the instance methods found by this visitor.
8055  return InstanceMethods;
8056  }
8057 
8058  /// Retrieve the instance methods found by this visitor.
8060  return FactoryMethods;
8061  }
8062 
8063  unsigned getInstanceBits() const { return InstanceBits; }
8064  unsigned getFactoryBits() const { return FactoryBits; }
8065 
8067  return InstanceHasMoreThanOneDecl;
8068  }
8069 
8070  bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8071  };
8072 
8073 } // namespace serialization
8074 } // namespace clang
8075 
8076 /// Add the given set of methods to the method list.
8078  ObjCMethodList &List) {
8079  for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8080  S.addMethodToGlobalList(&List, Methods[I]);
8081  }
8082 }
8083 
8085  // Get the selector generation and update it to the current generation.
8086  unsigned &Generation = SelectorGeneration[Sel];
8087  unsigned PriorGeneration = Generation;
8088  Generation = getGeneration();
8089  SelectorOutOfDate[Sel] = false;
8090 
8091  // Search for methods defined with this selector.
8092  ++NumMethodPoolLookups;
8093  ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8094  ModuleMgr.visit(Visitor);
8095 
8096  if (Visitor.getInstanceMethods().empty() &&
8097  Visitor.getFactoryMethods().empty())
8098  return;
8099 
8100  ++NumMethodPoolHits;
8101 
8102  if (!getSema())
8103  return;
8104 
8105  Sema &S = *getSema();
8106  Sema::GlobalMethodPool::iterator Pos
8107  = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8108 
8109  Pos->second.first.setBits(Visitor.getInstanceBits());
8110  Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8111  Pos->second.second.setBits(Visitor.getFactoryBits());
8112  Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8113 
8114  // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8115  // when building a module we keep every method individually and may need to
8116  // update hasMoreThanOneDecl as we add the methods.
8117  addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8118  addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8119 }
8120 
8122  if (SelectorOutOfDate[Sel])
8123  ReadMethodPool(Sel);
8124 }
8125 
8127  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8128  Namespaces.clear();
8129 
8130  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8131  if (NamespaceDecl *Namespace
8132  = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8133  Namespaces.push_back(Namespace);
8134  }
8135 }
8136 
8138  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8139  for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8140  NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8141  SourceLocation Loc =
8142  SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8143  Undefined.insert(std::make_pair(D, Loc));
8144  }
8145 }
8146 
8148  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8149  Exprs) {
8150  for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8151  FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8152  uint64_t Count = DelayedDeleteExprs[Idx++];
8153  for (uint64_t C = 0; C < Count; ++C) {
8154  SourceLocation DeleteLoc =
8155  SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8156  const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8157  Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8158  }
8159  }
8160 }
8161 
8163  SmallVectorImpl<VarDecl *> &TentativeDefs) {
8164  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8165  VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8166  if (Var)
8167  TentativeDefs.push_back(Var);
8168  }
8169  TentativeDefinitions.clear();
8170 }
8171 
8174  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8175  DeclaratorDecl *D
8176  = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8177  if (D)
8178  Decls.push_back(D);
8179  }
8180  UnusedFileScopedDecls.clear();
8181 }
8182 
8185  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8187  = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8188  if (D)
8189  Decls.push_back(D);
8190  }
8191  DelegatingCtorDecls.clear();
8192 }
8193 
8195  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8196  TypedefNameDecl *D
8197  = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8198  if (D)
8199  Decls.push_back(D);
8200  }
8201  ExtVectorDecls.clear();
8202 }
8203 
8206  for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8207  ++I) {
8208  TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8209  GetDecl(UnusedLocalTypedefNameCandidates[I]));
8210  if (D)
8211  Decls.insert(D);
8212  }
8213  UnusedLocalTypedefNameCandidates.clear();
8214 }
8215 
8217  SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8218  if (ReferencedSelectorsData.empty())
8219  return;
8220 
8221  // If there are @selector references added them to its pool. This is for
8222  // implementation of -Wselector.
8223  unsigned int DataSize = ReferencedSelectorsData.size()-1;
8224  unsigned I = 0;
8225  while (I < DataSize) {
8226  Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8227  SourceLocation SelLoc
8228  = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8229  Sels.push_back(std::make_pair(Sel, SelLoc));
8230  }
8231  ReferencedSelectorsData.clear();
8232 }
8233 
8235  SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8236  if (WeakUndeclaredIdentifiers.empty())
8237  return;
8238 
8239  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8240  IdentifierInfo *WeakId
8241  = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8242  IdentifierInfo *AliasId
8243  = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8244  SourceLocation Loc
8245  = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8246  bool Used = WeakUndeclaredIdentifiers[I++];
8247  WeakInfo WI(AliasId, Loc);
8248  WI.setUsed(Used);
8249  WeakIDs.push_back(std::make_pair(WeakId, WI));
8250  }
8251  WeakUndeclaredIdentifiers.clear();
8252 }
8253 
8255  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8256  ExternalVTableUse VT;
8257  VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8258  VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8259  VT.DefinitionRequired = VTableUses[Idx++];
8260  VTables.push_back(VT);
8261  }
8262 
8263  VTableUses.clear();
8264 }
8265 
8267  SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8268  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8269  ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8270  SourceLocation Loc
8271  = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8272 
8273  Pending.push_back(std::make_pair(D, Loc));
8274  }
8275  PendingInstantiations.clear();
8276 }
8277 
8279  llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8280  &LPTMap) {
8281  for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8282  /* In loop */) {
8283  FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8284 
8285  auto LT = llvm::make_unique<LateParsedTemplate>();
8286  LT->D = GetDecl(LateParsedTemplates[Idx++]);
8287 
8288  ModuleFile *F = getOwningModuleFile(LT->D);
8289  assert(F && "No module");
8290 
8291  unsigned TokN = LateParsedTemplates[Idx++];
8292  LT->Toks.reserve(TokN);
8293  for (unsigned T = 0; T < TokN; ++T)
8294  LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8295 
8296  LPTMap.insert(std::make_pair(FD, std::move(LT)));
8297  }
8298 
8299  LateParsedTemplates.clear();
8300 }
8301 
8303  // It would be complicated to avoid reading the methods anyway. So don't.
8304  ReadMethodPool(Sel);
8305 }
8306 
8308  assert(ID && "Non-zero identifier ID required");
8309  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8310  IdentifiersLoaded[ID - 1] = II;
8311  if (DeserializationListener)
8312  DeserializationListener->IdentifierRead(ID, II);
8313 }
8314 
8315 /// Set the globally-visible declarations associated with the given
8316 /// identifier.
8317 ///
8318 /// If the AST reader is currently in a state where the given declaration IDs
8319 /// cannot safely be resolved, they are queued until it is safe to resolve
8320 /// them.
8321 ///
8322 /// \param II an IdentifierInfo that refers to one or more globally-visible
8323 /// declarations.
8324 ///
8325 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8326 /// visible at global scope.
8327 ///
8328 /// \param Decls if non-null, this vector will be populated with the set of
8329 /// deserialized declarations. These declarations will not be pushed into
8330 /// scope.
8331 void
8333  const SmallVectorImpl<uint32_t> &DeclIDs,
8334  SmallVectorImpl<Decl *> *Decls) {
8335  if (NumCurrentElementsDeserializing && !Decls) {
8336  PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8337  return;
8338  }
8339 
8340  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8341  if (!SemaObj) {
8342  // Queue this declaration so that it will be added to the
8343  // translation unit scope and identifier's declaration chain
8344  // once a Sema object is known.
8345  PreloadedDeclIDs.push_back(DeclIDs[I]);
8346  continue;
8347  }
8348 
8349  NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8350 
8351  // If we're simply supposed to record the declarations, do so now.
8352  if (Decls) {
8353  Decls->push_back(D);
8354  continue;
8355  }
8356 
8357  // Introduce this declaration into the translation-unit scope
8358  // and add it to the declaration chain for this identifier, so
8359  // that (unqualified) name lookup will find it.
8360  pushExternalDeclIntoScope(D, II);
8361  }
8362 }
8363 
8365  if (ID == 0)
8366  return nullptr;
8367 
8368  if (IdentifiersLoaded.empty()) {
8369  Error("no identifier table in AST file");
8370  return nullptr;
8371  }
8372 
8373  ID -= 1;
8374  if (!IdentifiersLoaded[ID]) {
8375  GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8376  assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8377  ModuleFile *M = I->second;
8378  unsigned Index = ID - M->BaseIdentifierID;
8379  const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8380 
8381  // All of the strings in the AST file are preceded by a 16-bit length.
8382  // Extract that 16-bit length to avoid having to execute strlen().
8383  // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8384  // unsigned integers. This is important to avoid integer overflow when
8385  // we cast them to 'unsigned'.
8386  const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8387  unsigned StrLen = (((unsigned) StrLenPtr[0])
8388  | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8389  auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8390  IdentifiersLoaded[ID] = &II;
8391  markIdentifierFromAST(*this, II);
8392  if (DeserializationListener)
8393  DeserializationListener->IdentifierRead(ID + 1, &II);
8394  }
8395 
8396  return IdentifiersLoaded[ID];
8397 }
8398 
8399 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8400  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8401 }
8402 
8403 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8404  if (LocalID < NUM_PREDEF_IDENT_IDS)
8405  return LocalID;
8406 
8407  if (!M.ModuleOffsetMap.empty())
8408  ReadModuleOffsetMap(M);
8409 
8411  = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8412  assert(I != M.IdentifierRemap.end()
8413  && "Invalid index into identifier index remap");
8414 
8415  return LocalID + I->second;
8416 }
8417 
8419  if (ID == 0)
8420  return nullptr;
8421 
8422  if (MacrosLoaded.empty()) {
8423  Error("no macro table in AST file");
8424  return nullptr;
8425  }
8426 
8427  ID -= NUM_PREDEF_MACRO_IDS;
8428  if (!MacrosLoaded[ID]) {
8430  = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8431  assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8432  ModuleFile *M = I->second;
8433  unsigned Index = ID - M->BaseMacroID;
8434  MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8435 
8436  if (DeserializationListener)
8437  DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8438  MacrosLoaded[ID]);
8439  }
8440 
8441  return MacrosLoaded[ID];
8442 }
8443 
8444 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8445  if (LocalID < NUM_PREDEF_MACRO_IDS)
8446  return LocalID;
8447 
8448  if (!M.ModuleOffsetMap.empty())
8449  ReadModuleOffsetMap(M);
8450 
8452  = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8453  assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8454 
8455  return LocalID + I->second;
8456 }
8457 
8459 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8460  if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8461  return LocalID;
8462 
8463  if (!M.ModuleOffsetMap.empty())
8464  ReadModuleOffsetMap(M);
8465 
8468  assert(I != M.SubmoduleRemap.end()
8469  && "Invalid index into submodule index remap");
8470 
8471  return LocalID + I->second;
8472 }
8473 
8475  if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8476  assert(GlobalID == 0 && "Unhandled global submodule ID");
8477  return nullptr;
8478  }
8479 
8480  if (GlobalID > SubmodulesLoaded.size()) {
8481  Error("submodule ID out of range in AST file");
8482  return nullptr;
8483  }
8484 
8485  return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8486 }
8487 
8489  return getSubmodule(ID);
8490 }
8491 
8493  ModuleFile *MF = getOwningModuleFile(D);
8494  return MF && MF->PCHHasObjectFile;
8495 }
8496 
8497 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8498  if (ID & 1) {
8499  // It's a module, look it up by submodule ID.
8500  auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8501  return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8502  } else {
8503  // It's a prefix (preamble, PCH, ...). Look it up by index.
8504  unsigned IndexFromEnd = ID >> 1;
8505  assert(IndexFromEnd && "got reference to unknown module file");
8506  return getModuleManager().pch_modules().end()[-IndexFromEnd];
8507  }
8508 }
8509 
8510 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8511  if (!F)
8512  return 1;
8513 
8514  // For a file representing a module, use the submodule ID of the top-level
8515  // module as the file ID. For any other kind of file, the number of such
8516  // files loaded beforehand will be the same on reload.
8517  // FIXME: Is this true even if we have an explicit module file and a PCH?
8518  if (F->isModule())
8519  return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8520 
8521  auto PCHModules = getModuleManager().pch_modules();
8522  auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
8523  assert(I != PCHModules.end() && "emitting reference to unknown file");
8524  return (I - PCHModules.end()) << 1;
8525 }
8526 
8529  if (const Module *M = getSubmodule(ID))
8531 
8532  // If there is only a single PCH, return it instead.
8533  // Chained PCH are not supported.
8534  const auto &PCHChain = ModuleMgr.pch_modules();
8535  if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8536  ModuleFile &MF = ModuleMgr.getPrimaryModule();
8537  StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8538  StringRef FileName = llvm::sys::path::filename(MF.FileName);
8539  return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8540  MF.Signature);
8541  }
8542  return None;
8543 }
8544 
8546  auto I = DefinitionSource.find(FD);
8547  if (I == DefinitionSource.end())
8548  return EK_ReplyHazy;
8549  return I->second ? EK_Never : EK_Always;
8550 }
8551 
8552 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8553  return DecodeSelector(getGlobalSelectorID(M, LocalID));
8554 }
8555 
8557  if (ID == 0)
8558  return Selector();
8559 
8560  if (ID > SelectorsLoaded.size()) {
8561  Error("selector ID out of range in AST file");
8562  return Selector();
8563  }
8564 
8565  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8566  // Load this selector from the selector table.
8567  GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8568  assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8569  ModuleFile &M = *I->second;
8570  ASTSelectorLookupTrait Trait(*this, M);
8571  unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8572  SelectorsLoaded[ID - 1] =
8573  Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8574  if (DeserializationListener)
8575  DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8576  }
8577 
8578  return SelectorsLoaded[ID - 1];
8579 }
8580 
8582  return DecodeSelector(ID);
8583 }
8584 
8586  // ID 0 (the null selector) is considered an external selector.
8587  return getTotalNumSelectors() + 1;
8588 }
8589 
8591 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8592  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8593  return LocalID;
8594 
8595  if (!M.ModuleOffsetMap.empty())
8596  ReadModuleOffsetMap(M);
8597 
8600  assert(I != M.SelectorRemap.end()
8601  && "Invalid index into selector index remap");
8602 
8603  return LocalID + I->second;
8604 }
8605 
8608  const RecordData &Record, unsigned &Idx) {
8609  ASTContext &Context = getContext();
8611  switch (Kind) {
8613  return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8614 
8618  return DeclarationName(ReadSelector(F, Record, Idx));
8619 
8621  return Context.DeclarationNames.getCXXConstructorName(
8622  Context.getCanonicalType(readType(F, Record, Idx)));
8623 
8625  return Context.DeclarationNames.getCXXDestructorName(
8626  Context.getCanonicalType(readType(F, Record, Idx)));
8627 
8630  ReadDeclAs<TemplateDecl>(F, Record, Idx));
8631 
8634  Context.getCanonicalType(readType(F, Record, Idx)));
8635 
8637  return Context.DeclarationNames.getCXXOperatorName(
8638  (OverloadedOperatorKind)Record[Idx++]);
8639 
8642  GetIdentifierInfo(F, Record, Idx));
8643 
8646  }
8647 
8648  llvm_unreachable("Invalid NameKind!");
8649 }
8650 
8652  DeclarationNameLoc &DNLoc,
8653  DeclarationName Name,
8654  const RecordData &Record, unsigned &Idx) {
8655  switch (Name.getNameKind()) {
8659  DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8660  break;
8661 
8664  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8666  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8667  break;
8668 
8671  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8672  break;
8673 
8680  break;
8681  }
8682 }
8683 
8685  DeclarationNameInfo &NameInfo,
8686  const RecordData &Record, unsigned &Idx) {
8687  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8688  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8689  DeclarationNameLoc DNLoc;
8690  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8691  NameInfo.setInfo(DNLoc);
8692 }
8693 
8695  const RecordData &Record, unsigned &Idx) {
8696  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8697  unsigned NumTPLists = Record[Idx++];
8698  Info.NumTemplParamLists = NumTPLists;
8699  if (NumTPLists) {
8700  Info.TemplParamLists =
8701  new (getContext()) TemplateParameterList *[NumTPLists];
8702  for (unsigned i = 0; i != NumTPLists; ++i)
8703  Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8704  }
8705 }
8706 
8708 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8709  unsigned &Idx) {
8710  ASTContext &Context = getContext();
8712  switch (Kind) {
8714  return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8715 
8717  unsigned size = Record[Idx++];
8718  UnresolvedSet<8> Decls;
8719  while (size--)
8720  Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8721 
8722  return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8723  }
8724 
8726  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8727  bool hasTemplKeyword = Record[Idx++];
8728  TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8729  return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8730  }
8731 
8733  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8734  if (Record[Idx++]) // isIdentifier
8735  return Context.getDependentTemplateName(NNS,
8736  GetIdentifierInfo(F, Record,
8737  Idx));
8738  return Context.getDependentTemplateName(NNS,
8739  (OverloadedOperatorKind)Record[Idx++]);
8740  }
8741 
8744  = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8745  if (!param) return TemplateName();
8746  TemplateName replacement = ReadTemplateName(F, Record, Idx);
8747  return Context.getSubstTemplateTemplateParm(param, replacement);
8748  }
8749 
8752  = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8753  if (!Param)
8754  return TemplateName();
8755 
8756  TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8757  if (ArgPack.getKind() != TemplateArgument::Pack)
8758  return TemplateName();
8759 
8760  return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8761  }
8762  }
8763 
8764  llvm_unreachable("Unhandled template name kind!");
8765 }
8766 
8768  const RecordData &Record,
8769  unsigned &Idx,
8770  bool Canonicalize) {
8771  ASTContext &Context = getContext();
8772  if (Canonicalize) {
8773  // The caller wants a canonical template argument. Sometimes the AST only
8774  // wants template arguments in canonical form (particularly as the template
8775  // argument lists of template specializations) so ensure we preserve that
8776  // canonical form across serialization.
8777  TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8778  return Context.getCanonicalTemplateArgument(Arg);
8779  }
8780 
8782  switch (Kind) {
8784  return TemplateArgument();
8786  return TemplateArgument(readType(F, Record, Idx));
8788  ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8789  return TemplateArgument(D, readType(F, Record, Idx));
8790  }
8792  return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8794  llvm::APSInt Value = ReadAPSInt(Record, Idx);
8795  QualType T = readType(F, Record, Idx);
8796  return TemplateArgument(Context, Value, T);
8797  }
8799  return TemplateArgument(ReadTemplateName(F, Record, Idx));
8801  TemplateName Name = ReadTemplateName(F, Record, Idx);
8802  Optional<unsigned> NumTemplateExpansions;
8803  if (unsigned NumExpansions = Record[Idx++])
8804  NumTemplateExpansions = NumExpansions - 1;
8805  return TemplateArgument(Name, NumTemplateExpansions);
8806  }
8808  return TemplateArgument(ReadExpr(F));
8809  case TemplateArgument::Pack: {
8810  unsigned NumArgs = Record[Idx++];
8811  TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8812  for (unsigned I = 0; I != NumArgs; ++I)
8813  Args[I] = ReadTemplateArgument(F, Record, Idx);
8814  return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8815  }
8816  }
8817 
8818  llvm_unreachable("Unhandled template argument kind!");
8819 }
8820 
8823  const RecordData &Record, unsigned &Idx) {
8824  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8825  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8826  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8827 
8828  unsigned NumParams = Record[Idx++];
8830  Params.reserve(NumParams);
8831  while (NumParams--)
8832  Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8833 
8834  // TODO: Concepts
8836  getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8837  return TemplateParams;
8838 }
8839 
8840 void
8843  ModuleFile &F, const RecordData &Record,
8844  unsigned &Idx, bool Canonicalize) {
8845  unsigned NumTemplateArgs = Record[Idx++];
8846  TemplArgs.reserve(NumTemplateArgs);
8847  while (NumTemplateArgs--)
8848  TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8849 }
8850 
8851 /// Read a UnresolvedSet structure.
8853  const RecordData &Record, unsigned &Idx) {
8854  unsigned NumDecls = Record[Idx++];
8855  Set.reserve(getContext(), NumDecls);
8856  while (NumDecls--) {
8857  DeclID ID = ReadDeclID(F, Record, Idx);
8858  AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8859  Set.addLazyDecl(getContext(), ID, AS);
8860  }
8861 }
8862 
8865  const RecordData &Record, unsigned &Idx) {
8866  bool isVirtual = static_cast<bool>(Record[Idx++]);
8867  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8868  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8869  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8870  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8871  SourceRange Range = ReadSourceRange(F, Record, Idx);
8872  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8873  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8874  EllipsisLoc);
8875  Result.setInheritConstructors(inheritConstructors);
8876  return Result;
8877 }
8878 
8880 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8881  unsigned &Idx) {
8882  ASTContext &Context = getContext();
8883  unsigned NumInitializers = Record[Idx++];
8884  assert(NumInitializers && "wrote ctor initializers but have no inits");
8885  auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8886  for (unsigned i = 0; i != NumInitializers; ++i) {
8887  TypeSourceInfo *TInfo = nullptr;
8888  bool IsBaseVirtual = false;
8889  FieldDecl *Member = nullptr;
8890  IndirectFieldDecl *IndirectMember = nullptr;
8891 
8892  CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8893  switch (Type) {
8894  case CTOR_INITIALIZER_BASE:
8895  TInfo = GetTypeSourceInfo(F, Record, Idx);
8896  IsBaseVirtual = Record[Idx++];
8897  break;
8898 
8900  TInfo = GetTypeSourceInfo(F, Record, Idx);
8901  break;
8902 
8904  Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8905  break;
8906 
8908  IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8909  break;
8910  }
8911 
8912  SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8913  Expr *Init = ReadExpr(F);
8914  SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8915  SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8916 
8917  CXXCtorInitializer *BOMInit;
8918  if (Type == CTOR_INITIALIZER_BASE)
8919  BOMInit = new (Context)
8920  CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8921  RParenLoc, MemberOrEllipsisLoc);
8922  else if (Type == CTOR_INITIALIZER_DELEGATING)
8923  BOMInit = new (Context)
8924  CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8925  else if (Member)
8926  BOMInit = new (Context)
8927  CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8928  Init, RParenLoc);
8929  else
8930  BOMInit = new (Context)
8931  CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8932  LParenLoc, Init, RParenLoc);
8933 
8934  if (/*IsWritten*/Record[Idx++]) {
8935  unsigned SourceOrder = Record[Idx++];
8936  BOMInit->setSourceOrder(SourceOrder);
8937  }
8938 
8939  CtorInitializers[i] = BOMInit;
8940  }
8941 
8942  return CtorInitializers;
8943 }
8944 
8947  const RecordData &Record, unsigned &Idx) {
8948  ASTContext &Context = getContext();
8949  unsigned N = Record[Idx++];
8950  NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8951  for (unsigned I = 0; I != N; ++I) {
8953  = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8954  switch (Kind) {
8956  IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8957  NNS = NestedNameSpecifier::Create(Context, Prev, II);
8958  break;
8959  }
8960 
8962  NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8963  NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8964  break;
8965  }
8966 
8968  NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8969  NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8970  break;
8971  }
8972 
8975  const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8976  if (!T)
8977  return nullptr;
8978 
8979  bool Template = Record[Idx++];
8980  NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8981  break;
8982  }
8983 
8985  NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8986  // No associated value, and there can't be a prefix.
8987  break;
8988 
8990  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8991  NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8992  break;
8993  }
8994  }
8995  Prev = NNS;
8996  }
8997  return NNS;
8998 }
8999 
9002  unsigned &Idx) {
9003  ASTContext &Context = getContext();
9004  unsigned N = Record[Idx++];
9006  for (unsigned I = 0; I != N; ++I) {
9008  = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9009  switch (Kind) {
9011  IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
9012  SourceRange Range = ReadSourceRange(F, Record, Idx);
9013  Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9014  break;
9015  }
9016 
9018  NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
9019  SourceRange Range = ReadSourceRange(F, Record, Idx);
9020  Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9021  break;
9022  }
9023 
9025  NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9026  SourceRange Range = ReadSourceRange(F, Record, Idx);
9027  Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9028  break;
9029  }
9030 
9033  bool Template = Record[Idx++];
9034  TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
9035  if (!T)
9036  return NestedNameSpecifierLoc();
9037  SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9038 
9039  // FIXME: 'template' keyword location not saved anywhere, so we fake it.
9040  Builder.Extend(Context,
9041  Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
9042  T->getTypeLoc(), ColonColonLoc);
9043  break;
9044  }
9045 
9047  SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9048  Builder.MakeGlobal(Context, ColonColonLoc);
9049  break;
9050  }
9051 
9053  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9054  SourceRange Range = ReadSourceRange(F, Record, Idx);
9055  Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9056  break;
9057  }
9058  }
9059  }
9060 
9061  return Builder.getWithLocInContext(Context);
9062 }
9063 
9065 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
9066  unsigned &Idx) {
9067  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
9068  SourceLocation end = ReadSourceLocation(F, Record, Idx);
9069  return SourceRange(beg, end);
9070 }
9071 
9072 /// Read an integral value
9073 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
9074  unsigned BitWidth = Record[Idx++];
9075  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
9076  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
9077  Idx += NumWords;
9078  return Result;
9079 }
9080 
9081 /// Read a signed integral value
9082 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
9083  bool isUnsigned = Record[Idx++];
9084  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
9085 }
9086 
9087 /// Read a floating-point value
9088 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
9089  const llvm::fltSemantics &Sem,
9090  unsigned &Idx) {
9091  return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
9092 }
9093 
9094 // Read a string
9095 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9096  unsigned Len = Record[Idx++];
9097  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9098  Idx += Len;
9099  return Result;
9100 }
9101 
9102 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9103  unsigned &Idx) {
9104  std::string Filename = ReadString(Record, Idx);
9105  ResolveImportedPath(F, Filename);
9106  return Filename;
9107 }
9108 
9109 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9110  unsigned &Idx) {
9111  unsigned Major = Record[Idx++];
9112  unsigned Minor = Record[Idx++];
9113  unsigned Subminor = Record[Idx++];
9114  if (Minor == 0)
9115  return VersionTuple(Major);
9116  if (Subminor == 0)
9117  return VersionTuple(Major, Minor - 1);
9118  return VersionTuple(Major, Minor - 1, Subminor - 1);
9119 }
9120 
9122  const RecordData &Record,
9123  unsigned &Idx) {
9124  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9125  return CXXTemporary::Create(getContext(), Decl);
9126 }
9127 
9128 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9129  return Diag(CurrentImportLoc, DiagID);
9130 }
9131 
9132 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9133  return Diags.Report(Loc, DiagID);
9134 }
9135 
9136 /// Retrieve the identifier table associated with the
9137 /// preprocessor.
9139  return PP.getIdentifierTable();
9140 }
9141 
9142 /// Record that the given ID maps to the given switch-case
9143 /// statement.
9145  assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9146  "Already have a SwitchCase with this ID");
9147  (*CurrSwitchCaseStmts)[ID] = SC;
9148 }
9149 
9150 /// Retrieve the switch-case statement with the given ID.
9152  assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9153  return (*CurrSwitchCaseStmts)[ID];
9154 }
9155 
9157  CurrSwitchCaseStmts->clear();
9158 }
9159 
9161  ASTContext &Context = getContext();
9162  std::vector<RawComment *> Comments;
9163  for (SmallVectorImpl<std::pair<BitstreamCursor,
9164  serialization::ModuleFile *>>::iterator
9165  I = CommentsCursors.begin(),
9166  E = CommentsCursors.end();
9167  I != E; ++I) {
9168  Comments.clear();
9169  BitstreamCursor &Cursor = I->first;
9170  serialization::ModuleFile &F = *I->second;
9171  SavedStreamPosition SavedPosition(Cursor);
9172 
9173  RecordData Record;
9174  while (true) {
9175  llvm::BitstreamEntry Entry =
9176  Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
9177 
9178  switch (Entry.Kind) {
9179  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9181  Error("malformed block record in AST file");
9182  return;
9183  case llvm::BitstreamEntry::EndBlock:
9184  goto NextCursor;
9185  case llvm::BitstreamEntry::Record:
9186  // The interesting case.
9187  break;
9188  }
9189 
9190  // Read a record.
9191  Record.clear();
9192  switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
9193  case COMMENTS_RAW_COMMENT: {
9194  unsigned Idx = 0;
9195  SourceRange SR = ReadSourceRange(F, Record, Idx);
9197  (RawComment::CommentKind) Record[Idx++];
9198  bool IsTrailingComment = Record[Idx++];
9199  bool IsAlmostTrailingComment = Record[Idx++];
9200  Comments.push_back(new (Context) RawComment(
9201  SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9202  break;
9203  }
9204  }
9205  }
9206  NextCursor:
9207  // De-serialized SourceLocations get negative FileIDs for other modules,
9208  // potentially invalidating the original order. Sort it again.
9209  llvm::sort(Comments.begin(), Comments.end(),
9210  BeforeThanCompare<RawComment>(SourceMgr));
9211  Context.Comments.addDeserializedComments(Comments);
9212  }
9213 }
9214 
9216  bool IncludeSystem, bool Complain,
9217  llvm::function_ref<void(const serialization::InputFile &IF,
9218  bool isSystem)> Visitor) {
9219  unsigned NumUserInputs = MF.NumUserInputFiles;
9220  unsigned NumInputs = MF.InputFilesLoaded.size();
9221  assert(NumUserInputs <= NumInputs);
9222  unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9223  for (unsigned I = 0; I < N; ++I) {
9224  bool IsSystem = I >= NumUserInputs;
9225  InputFile IF = getInputFile(MF, I+1, Complain);
9226  Visitor(IF, IsSystem);
9227  }
9228 }
9229 
9232  llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9233  unsigned NumInputs = MF.InputFilesLoaded.size();
9234  for (unsigned I = 0; I < NumInputs; ++I) {
9235  InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9236  if (IFI.TopLevelModuleMap)
9237  // FIXME: This unnecessarily re-reads the InputFileInfo.
9238  if (auto *FE = getInputFile(MF, I + 1).getFile())
9239  Visitor(FE);
9240  }
9241 }
9242 
9244  // If we know the owning module, use it.
9245  if (Module *M = D->getImportedOwningModule())
9246  return M->getFullModuleName();
9247 
9248  // Otherwise, use the name of the top-level module the decl is within.
9249  if (ModuleFile *M = getOwningModuleFile(D))
9250  return M->ModuleName;
9251 
9252  // Not from a module.
9253  return {};
9254 }
9255 
9256 void ASTReader::finishPendingActions() {
9257  while (!PendingIdentifierInfos.empty() ||
9258  !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9259  !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9260  !PendingUpdateRecords.empty()) {
9261  // If any identifiers with corresponding top-level declarations have
9262  // been loaded, load those declarations now.
9263  using TopLevelDeclsMap =
9264  llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9265  TopLevelDeclsMap TopLevelDecls;
9266 
9267  while (!PendingIdentifierInfos.empty()) {
9268  IdentifierInfo *II = PendingIdentifierInfos.back().first;
9269  SmallVector<uint32_t, 4> DeclIDs =
9270  std::move(PendingIdentifierInfos.back().second);
9271  PendingIdentifierInfos.pop_back();
9272 
9273  SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9274  }
9275 
9276  // For each decl chain that we wanted to complete while deserializing, mark
9277  // it as "still needs to be completed".
9278  for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9279  markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9280  }
9281  PendingIncompleteDeclChains.clear();
9282 
9283  // Load pending declaration chains.
9284  for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9285  loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
9286  PendingDeclChains.clear();
9287 
9288  // Make the most recent of the top-level declarations visible.
9289  for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9290  TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9291  IdentifierInfo *II = TLD->first;
9292  for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9293  pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9294  }
9295  }
9296 
9297  // Load any pending macro definitions.
9298  for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9299  IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9301  GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9302  // Initialize the macro history from chained-PCHs ahead of module imports.
9303  for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9304  ++IDIdx) {
9305  const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9306  if (!Info.M->isModule())
9307  resolvePendingMacro(II, Info);
9308  }
9309  // Handle module imports.
9310  for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9311  ++IDIdx) {
9312  const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9313  if (Info.M->isModule())
9314  resolvePendingMacro(II, Info);
9315  }
9316  }
9317  PendingMacroIDs.clear();
9318 
9319  // Wire up the DeclContexts for Decls that we delayed setting until
9320  // recursive loading is completed.
9321  while (!PendingDeclContextInfos.empty()) {
9322  PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9323  PendingDeclContextInfos.pop_front();
9324  DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9325  DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9326  Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9327  }
9328 
9329  // Perform any pending declaration updates.
9330  while (!PendingUpdateRecords.empty()) {
9331  auto Update = PendingUpdateRecords.pop_back_val();
9332  ReadingKindTracker ReadingKind(Read_Decl, *this);
9333  loadDeclUpdateRecords(Update);
9334  }
9335  }
9336 
9337  // At this point, all update records for loaded decls are in place, so any
9338  // fake class definitions should have become real.
9339  assert(PendingFakeDefinitionData.empty() &&
9340  "faked up a class definition but never saw the real one");
9341 
9342  // If we deserialized any C++ or Objective-C class definitions, any
9343  // Objective-C protocol definitions, or any redeclarable templates, make sure
9344  // that all redeclarations point to the definitions. Note that this can only
9345  // happen now, after the redeclaration chains have been fully wired.
9346  for (Decl *D : PendingDefinitions) {
9347  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9348  if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9349  // Make sure that the TagType points at the definition.
9350  const_cast<TagType*>(TagT)->decl = TD;
9351  }
9352 
9353  if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9354  for (auto *R = getMostRecentExistingDecl(RD); R;
9355  R = R->getPreviousDecl()) {
9356  assert((R == D) ==
9357  cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9358  "declaration thinks it's the definition but it isn't");
9359  cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9360  }
9361  }
9362 
9363  continue;
9364  }
9365 
9366  if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9367  // Make sure that the ObjCInterfaceType points at the definition.
9368  const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9369  ->Decl = ID;
9370 
9371  for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9372  cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9373 
9374  continue;
9375  }
9376 
9377  if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9378  for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9379  cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9380 
9381  continue;
9382  }
9383 
9384  auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9385  for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9386  cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9387  }
9388  PendingDefinitions.clear();
9389 
9390  // Load the bodies of any functions or methods we've encountered. We do
9391  // this now (delayed) so that we can be sure that the declaration chains
9392  // have been fully wired up (hasBody relies on this).
9393  // FIXME: We shouldn't require complete redeclaration chains here.
9394  for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9395  PBEnd = PendingBodies.end();
9396  PB != PBEnd; ++PB) {
9397  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9398  // For a function defined inline within a class template, force the
9399  // canonical definition to be the one inside the canonical definition of
9400  // the template. This ensures that we instantiate from a correct view
9401  // of the template.
9402  //
9403  // Sadly we can't do this more generally: we can't be sure that all
9404  // copies of an arbitrary class definition will have the same members
9405  // defined (eg, some member functions may not be instantiated, and some
9406  // special members may or may not have been implicitly defined).
9407  if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9408  if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9409  continue;
9410 
9411  // FIXME: Check for =delete/=default?
9412  // FIXME: Complain about ODR violations here?
9413  const FunctionDecl *Defn = nullptr;
9414  if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9415  FD->setLazyBody(PB->second);
9416  } else {
9417  auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9418  mergeDefinitionVisibility(NonConstDefn, FD);
9419 
9420  if (!FD->isLateTemplateParsed() &&
9421  !NonConstDefn->isLateTemplateParsed() &&
9422  FD->getODRHash() != NonConstDefn->getODRHash()) {
9423  if (!isa<CXXMethodDecl>(FD)) {
9424  PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9425  } else if (FD->getLexicalParent()->isFileContext() &&
9426  NonConstDefn->getLexicalParent()->isFileContext()) {
9427  // Only diagnose out-of-line method definitions. If they are
9428  // in class definitions, then an error will be generated when
9429  // processing the class bodies.
9430  PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9431  }
9432  }
9433  }
9434  continue;
9435  }
9436 
9437  ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9438  if (!getContext().getLangOpts().Modules || !MD->hasBody())
9439  MD->setLazyBody(PB->second);
9440  }
9441  PendingBodies.clear();
9442 
9443  // Do some cleanup.
9444  for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9445  getContext().deduplicateMergedDefinitonsFor(ND);
9446  PendingMergedDefinitionsToDeduplicate.clear();
9447 }
9448 
9449 void ASTReader::diagnoseOdrViolations() {
9450  if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9451  PendingFunctionOdrMergeFailures.empty() &&
9452  PendingEnumOdrMergeFailures.empty())
9453  return;
9454 
9455  // Trigger the import of the full definition of each class that had any
9456  // odr-merging problems, so we can produce better diagnostics for them.
9457  // These updates may in turn find and diagnose some ODR failures, so take
9458  // ownership of the set first.
9459  auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9460  PendingOdrMergeFailures.clear();
9461  for (auto &Merge : OdrMergeFailures) {
9462  Merge.first->buildLookup();
9463  Merge.first->decls_begin();
9464  Merge.first->bases_begin();
9465  Merge.first->vbases_begin();
9466  for (auto &RecordPair : Merge.second) {
9467  auto *RD = RecordPair.first;
9468  RD->decls_begin();
9469  RD->bases_begin();
9470  RD->vbases_begin();
9471  }
9472  }
9473 
9474  // Trigger the import of functions.
9475  auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9476  PendingFunctionOdrMergeFailures.clear();
9477  for (auto &Merge : FunctionOdrMergeFailures) {
9478  Merge.first->buildLookup();
9479  Merge.first->decls_begin();
9480  Merge.first->getBody();
9481  for (auto &FD : Merge.second) {
9482  FD->buildLookup();
9483  FD->decls_begin();
9484  FD->getBody();
9485  }
9486  }
9487 
9488  // Trigger the import of enums.
9489  auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9490  PendingEnumOdrMergeFailures.clear();
9491  for (auto &Merge : EnumOdrMergeFailures) {
9492  Merge.first->decls_begin();
9493  for (auto &Enum : Merge.second) {
9494  Enum->decls_begin();
9495  }
9496  }
9497 
9498  // For each declaration from a merged context, check that the canonical
9499  // definition of that context also contains a declaration of the same
9500  // entity.
9501  //
9502  // Caution: this loop does things that might invalidate iterators into
9503  // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9504  while (!PendingOdrMergeChecks.empty()) {
9505  NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9506 
9507  // FIXME: Skip over implicit declarations for now. This matters for things
9508  // like implicitly-declared special member functions. This isn't entirely
9509  // correct; we can end up with multiple unmerged declarations of the same
9510  // implicit entity.
9511  if (D->isImplicit())
9512  continue;
9513 
9514  DeclContext *CanonDef = D->getDeclContext();
9515 
9516  bool Found = false;
9517  const Decl *DCanon = D->getCanonicalDecl();
9518 
9519  for (auto RI : D->redecls()) {
9520  if (RI->getLexicalDeclContext() == CanonDef) {
9521  Found = true;
9522  break;
9523  }
9524  }
9525  if (Found)
9526  continue;
9527 
9528  // Quick check failed, time to do the slow thing. Note, we can't just
9529  // look up the name of D in CanonDef here, because the member that is
9530  // in CanonDef might not be found by name lookup (it might have been
9531  // replaced by a more recent declaration in the lookup table), and we
9532  // can't necessarily find it in the redeclaration chain because it might
9533  // be merely mergeable, not redeclarable.
9535  for (auto *CanonMember : CanonDef->decls()) {
9536  if (CanonMember->getCanonicalDecl() == DCanon) {
9537  // This can happen if the declaration is merely mergeable and not
9538  // actually redeclarable (we looked for redeclarations earlier).
9539  //
9540  // FIXME: We should be able to detect this more efficiently, without
9541  // pulling in all of the members of CanonDef.
9542  Found = true;
9543  break;
9544  }
9545  if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9546  if (ND->getDeclName() == D->getDeclName())
9547  Candidates.push_back(ND);
9548  }
9549 
9550  if (!Found) {
9551  // The AST doesn't like TagDecls becoming invalid after they've been
9552  // completed. We only really need to mark FieldDecls as invalid here.
9553  if (!isa<TagDecl>(D))
9554  D->setInvalidDecl();
9555 
9556  // Ensure we don't accidentally recursively enter deserialization while
9557  // we're producing our diagnostic.
9558  Deserializing RecursionGuard(this);
9559 
9560  std::string CanonDefModule =
9561  getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9562  Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9563  << D << getOwningModuleNameForDiagnostic(D)
9564  << CanonDef << CanonDefModule.empty() << CanonDefModule;
9565 
9566  if (Candidates.empty())
9567  Diag(cast<Decl>(CanonDef)->getLocation(),
9568  diag::note_module_odr_violation_no_possible_decls) << D;
9569  else {
9570  for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9571  Diag(Candidates[I]->getLocation(),
9572  diag::note_module_odr_violation_possible_decl)
9573  << Candidates[I];
9574  }
9575 
9576  DiagnosedOdrMergeFailures.insert(CanonDef);
9577  }
9578  }
9579 
9580  if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9581  EnumOdrMergeFailures.empty())
9582  return;
9583 
9584  // Ensure we don't accidentally recursively enter deserialization while
9585  // we're producing our diagnostics.
9586  Deserializing RecursionGuard(this);
9587 
9588  // Common code for hashing helpers.
9589  ODRHash Hash;
9590  auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9591  Hash.clear();
9592  Hash.AddQualType(Ty);
9593  return Hash.CalculateHash();
9594  };
9595 
9596  auto ComputeODRHash = [&Hash](const Stmt *S) {
9597  assert(S);
9598  Hash.clear();
9599  Hash.AddStmt(S);
9600  return Hash.CalculateHash();
9601  };
9602 
9603  auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9604  assert(D);
9605  Hash.clear();
9606  Hash.AddSubDecl(D);
9607  return Hash.CalculateHash();
9608  };
9609 
9610  auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9611  Hash.clear();
9612  Hash.AddTemplateArgument(TA);
9613  return Hash.CalculateHash();
9614  };
9615 
9616  auto ComputeTemplateParameterListODRHash =
9617  [&Hash](const TemplateParameterList *TPL) {
9618  assert(TPL);
9619  Hash.clear();
9620  Hash.AddTemplateParameterList(TPL);
9621  return Hash.CalculateHash();
9622  };
9623 
9624  // Issue any pending ODR-failure diagnostics.
9625  for (auto &Merge : OdrMergeFailures) {
9626  // If we've already pointed out a specific problem with this class, don't
9627  // bother issuing a general "something's different" diagnostic.
9628  if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9629  continue;
9630 
9631  bool Diagnosed = false;
9632  CXXRecordDecl *FirstRecord = Merge.first;
9633  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9634  for (auto &RecordPair : Merge.second) {
9635  CXXRecordDecl *SecondRecord = RecordPair.first;
9636  // Multiple different declarations got merged together; tell the user
9637  // where they came from.
9638  if (FirstRecord == SecondRecord)
9639  continue;
9640 
9641  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9642 
9643  auto *FirstDD = FirstRecord->DefinitionData;
9644  auto *SecondDD = RecordPair.second;
9645 
9646  assert(FirstDD && SecondDD && "Definitions without DefinitionData");
9647 
9648  // Diagnostics from DefinitionData are emitted here.
9649  if (FirstDD != SecondDD) {
9650  enum ODRDefinitionDataDifference {
9651  NumBases,
9652  NumVBases,
9653  BaseType,
9654  BaseVirtual,
9655  BaseAccess,
9656  };
9657  auto ODRDiagError = [FirstRecord, &FirstModule,
9658  this](SourceLocation Loc, SourceRange Range,
9659  ODRDefinitionDataDifference DiffType) {
9660  return Diag(Loc, diag::err_module_odr_violation_definition_data)
9661  << FirstRecord << FirstModule.empty() << FirstModule << Range
9662  << DiffType;
9663  };
9664  auto ODRDiagNote = [&SecondModule,
9665  this](SourceLocation Loc, SourceRange Range,
9666  ODRDefinitionDataDifference DiffType) {
9667  return Diag(Loc, diag::note_module_odr_violation_definition_data)
9668  << SecondModule << Range << DiffType;
9669  };
9670 
9671  unsigned FirstNumBases = FirstDD->NumBases;
9672  unsigned FirstNumVBases = FirstDD->NumVBases;
9673  unsigned SecondNumBases = SecondDD->NumBases;
9674  unsigned SecondNumVBases = SecondDD->NumVBases;
9675 
9676  auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
9677  unsigned NumBases = DD->NumBases;
9678  if (NumBases == 0) return SourceRange();
9679  auto bases = DD->bases();
9680  return SourceRange(bases[0].getLocStart(),
9681  bases[NumBases - 1].getLocEnd());
9682  };
9683 
9684  if (FirstNumBases != SecondNumBases) {
9685  ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9686  NumBases)
9687  << FirstNumBases;
9688  ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9689  NumBases)
9690  << SecondNumBases;
9691  Diagnosed = true;
9692  break;
9693  }
9694 
9695  if (FirstNumVBases != SecondNumVBases) {
9696  ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9697  NumVBases)
9698  << FirstNumVBases;
9699  ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9700  NumVBases)
9701  << SecondNumVBases;
9702  Diagnosed = true;
9703  break;
9704  }
9705 
9706  auto FirstBases = FirstDD->bases();
9707  auto SecondBases = SecondDD->bases();
9708  unsigned i = 0;
9709  for (i = 0; i < FirstNumBases; ++i) {
9710  auto FirstBase = FirstBases[i];
9711  auto SecondBase = SecondBases[i];
9712  if (ComputeQualTypeODRHash(FirstBase.getType()) !=
9713  ComputeQualTypeODRHash(SecondBase.getType())) {
9714  ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9715  BaseType)
9716  << (i + 1) << FirstBase.getType();
9717  ODRDiagNote(SecondRecord->getLocation(),
9718  SecondBase.getSourceRange(), BaseType)
9719  << (i + 1) << SecondBase.getType();
9720  break;
9721  }
9722 
9723  if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
9724  ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9725  BaseVirtual)
9726  << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
9727  ODRDiagNote(SecondRecord->getLocation(),
9728  SecondBase.getSourceRange(), BaseVirtual)
9729  << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
9730  break;
9731  }
9732 
9733  if (FirstBase.getAccessSpecifierAsWritten() !=
9734  SecondBase.getAccessSpecifierAsWritten()) {
9735  ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9736  BaseAccess)
9737  << (i + 1) << FirstBase.getType()
9738  << (int)FirstBase.getAccessSpecifierAsWritten();
9739  ODRDiagNote(SecondRecord->getLocation(),
9740  SecondBase.getSourceRange(), BaseAccess)
9741  << (i + 1) << SecondBase.getType()
9742  << (int)SecondBase.getAccessSpecifierAsWritten();
9743  break;
9744  }
9745  }
9746 
9747  if (i != FirstNumBases) {
9748  Diagnosed = true;
9749  break;
9750  }
9751  }
9752 
9753  using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9754 
9755  const ClassTemplateDecl *FirstTemplate =
9756  FirstRecord->getDescribedClassTemplate();
9757  const ClassTemplateDecl *SecondTemplate =
9758  SecondRecord->getDescribedClassTemplate();
9759 
9760  assert(!FirstTemplate == !SecondTemplate &&
9761  "Both pointers should be null or non-null");
9762 
9763  enum ODRTemplateDifference {
9764  ParamEmptyName,
9765  ParamName,
9766  ParamSingleDefaultArgument,
9767  ParamDifferentDefaultArgument,
9768  };
9769 
9770  if (FirstTemplate && SecondTemplate) {
9771  DeclHashes FirstTemplateHashes;
9772  DeclHashes SecondTemplateHashes;
9773 
9774  auto PopulateTemplateParameterHashs =
9775  [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9776  const ClassTemplateDecl *TD) {
9777  for (auto *D : TD->getTemplateParameters()->asArray()) {
9778  Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9779  }
9780  };
9781 
9782  PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
9783  PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
9784 
9785  assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
9786  "Number of template parameters should be equal.");
9787 
9788  auto FirstIt = FirstTemplateHashes.begin();
9789  auto FirstEnd = FirstTemplateHashes.end();
9790  auto SecondIt = SecondTemplateHashes.begin();
9791  for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
9792  if (FirstIt->second == SecondIt->second)
9793  continue;
9794 
9795  auto ODRDiagError = [FirstRecord, &FirstModule,
9796  this](SourceLocation Loc, SourceRange Range,
9797  ODRTemplateDifference DiffType) {
9798  return Diag(Loc, diag::err_module_odr_violation_template_parameter)
9799  << FirstRecord << FirstModule.empty() << FirstModule << Range
9800  << DiffType;
9801  };
9802  auto ODRDiagNote = [&SecondModule,
9803  this](SourceLocation Loc, SourceRange Range,
9804  ODRTemplateDifference DiffType) {
9805  return Diag(Loc, diag::note_module_odr_violation_template_parameter)
9806  << SecondModule << Range << DiffType;
9807  };
9808 
9809  const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
9810  const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
9811 
9812  assert(FirstDecl->getKind() == SecondDecl->getKind() &&
9813  "Parameter Decl's should be the same kind.");
9814 
9815  DeclarationName FirstName = FirstDecl->getDeclName();
9816  DeclarationName SecondName = SecondDecl->getDeclName();
9817 
9818  if (FirstName != SecondName) {
9819  const bool FirstNameEmpty =
9820  FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
9821  const bool SecondNameEmpty =
9822  SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
9823  assert((!FirstNameEmpty || !SecondNameEmpty) &&
9824  "Both template parameters cannot be unnamed.");
9825  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9826  FirstNameEmpty ? ParamEmptyName : ParamName)
9827  << FirstName;
9828  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9829  SecondNameEmpty ? ParamEmptyName : ParamName)
9830  << SecondName;
9831  break;
9832  }
9833 
9834  switch (FirstDecl->getKind()) {
9835  default:
9836  llvm_unreachable("Invalid template parameter type.");
9837  case Decl::TemplateTypeParm: {
9838  const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
9839  const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
9840  const bool HasFirstDefaultArgument =
9841  FirstParam->hasDefaultArgument() &&
9842  !FirstParam->defaultArgumentWasInherited();
9843  const bool HasSecondDefaultArgument =
9844  SecondParam->hasDefaultArgument() &&
9845  !SecondParam->defaultArgumentWasInherited();
9846 
9847  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9848  ODRDiagError(FirstDecl->getLocation(),
9849  FirstDecl->getSourceRange(),
9850  ParamSingleDefaultArgument)
9851  << HasFirstDefaultArgument;
9852  ODRDiagNote(SecondDecl->getLocation(),
9853  SecondDecl->getSourceRange(),
9854  ParamSingleDefaultArgument)
9855  << HasSecondDefaultArgument;
9856  break;
9857  }
9858 
9859  assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9860  "Expecting default arguments.");
9861 
9862  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9863  ParamDifferentDefaultArgument);
9864  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9865  ParamDifferentDefaultArgument);
9866 
9867  break;
9868  }
9869  case Decl::NonTypeTemplateParm: {
9870  const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
9871  const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
9872  const bool HasFirstDefaultArgument =
9873  FirstParam->hasDefaultArgument() &&
9874  !FirstParam->defaultArgumentWasInherited();
9875  const bool HasSecondDefaultArgument =
9876  SecondParam->hasDefaultArgument() &&
9877  !SecondParam->defaultArgumentWasInherited();
9878 
9879  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9880  ODRDiagError(FirstDecl->getLocation(),
9881  FirstDecl->getSourceRange(),
9882  ParamSingleDefaultArgument)
9883  << HasFirstDefaultArgument;
9884  ODRDiagNote(SecondDecl->getLocation(),
9885  SecondDecl->getSourceRange(),
9886  ParamSingleDefaultArgument)
9887  << HasSecondDefaultArgument;
9888  break;
9889  }
9890 
9891  assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9892  "Expecting default arguments.");
9893 
9894  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9895  ParamDifferentDefaultArgument);
9896  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9897  ParamDifferentDefaultArgument);
9898 
9899  break;
9900  }
9901  case Decl::TemplateTemplateParm: {
9902  const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
9903  const auto *SecondParam =
9904  cast<TemplateTemplateParmDecl>(SecondDecl);
9905  const bool HasFirstDefaultArgument =
9906  FirstParam->hasDefaultArgument() &&
9907  !FirstParam->defaultArgumentWasInherited();
9908  const bool HasSecondDefaultArgument =
9909  SecondParam->hasDefaultArgument() &&
9910  !SecondParam->defaultArgumentWasInherited();
9911 
9912  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9913  ODRDiagError(FirstDecl->getLocation(),
9914  FirstDecl->getSourceRange(),
9915  ParamSingleDefaultArgument)
9916  << HasFirstDefaultArgument;
9917  ODRDiagNote(SecondDecl->getLocation(),
9918  SecondDecl->getSourceRange(),
9919  ParamSingleDefaultArgument)
9920  << HasSecondDefaultArgument;
9921  break;
9922  }
9923 
9924  assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9925  "Expecting default arguments.");
9926 
9927  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9928  ParamDifferentDefaultArgument);
9929  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9930  ParamDifferentDefaultArgument);
9931 
9932  break;
9933  }
9934  }
9935 
9936  break;
9937  }
9938 
9939  if (FirstIt != FirstEnd) {
9940  Diagnosed = true;
9941  break;
9942  }
9943  }
9944 
9945  DeclHashes FirstHashes;
9946  DeclHashes SecondHashes;
9947 
9948  auto PopulateHashes = [&ComputeSubDeclODRHash, FirstRecord](
9949  DeclHashes &Hashes, CXXRecordDecl *Record) {
9950  for (auto *D : Record->decls()) {
9951  // Due to decl merging, the first CXXRecordDecl is the parent of
9952  // Decls in both records.
9953  if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
9954  continue;
9955  Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9956  }
9957  };
9958  PopulateHashes(FirstHashes, FirstRecord);
9959  PopulateHashes(SecondHashes, SecondRecord);
9960 
9961  // Used with err_module_odr_violation_mismatch_decl and
9962  // note_module_odr_violation_mismatch_decl
9963  // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
9964  enum {
9965  EndOfClass,
9966  PublicSpecifer,
9967  PrivateSpecifer,
9968  ProtectedSpecifer,
9969  StaticAssert,
9970  Field,
9971  CXXMethod,
9972  TypeAlias,
9973  TypeDef,
9974  Var,
9975  Friend,
9976  FunctionTemplate,
9977  Other
9978  } FirstDiffType = Other,
9979  SecondDiffType = Other;
9980 
9981  auto DifferenceSelector = [](Decl *D) {
9982  assert(D && "valid Decl required");
9983  switch (D->getKind()) {
9984  default:
9985  return Other;
9986  case Decl::AccessSpec:
9987  switch (D->getAccess()) {
9988  case AS_public:
9989  return PublicSpecifer;
9990  case AS_private:
9991  return PrivateSpecifer;
9992  case AS_protected:
9993  return ProtectedSpecifer;
9994  case AS_none:
9995  break;
9996  }
9997  llvm_unreachable("Invalid access specifier");
9998  case Decl::StaticAssert:
9999  return StaticAssert;
10000  case Decl::Field:
10001  return Field;
10002  case Decl::CXXMethod:
10003  case Decl::CXXConstructor:
10004  case Decl::CXXDestructor:
10005  return CXXMethod;
10006  case Decl::TypeAlias:
10007  return TypeAlias;
10008  case Decl::Typedef:
10009  return TypeDef;
10010  case Decl::Var:
10011  return Var;
10012  case Decl::Friend:
10013  return Friend;
10014  case Decl::FunctionTemplate:
10015  return FunctionTemplate;
10016  }
10017  };
10018 
10019  Decl *FirstDecl = nullptr;
10020  Decl *SecondDecl = nullptr;
10021  auto FirstIt = FirstHashes.begin();
10022  auto SecondIt = SecondHashes.begin();
10023 
10024  // If there is a diagnoseable difference, FirstDiffType and
10025  // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
10026  // filled in if not EndOfClass.
10027  while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
10028  if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
10029  FirstIt->second == SecondIt->second) {
10030  ++FirstIt;
10031  ++SecondIt;
10032  continue;
10033  }
10034 
10035  FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
10036  SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
10037 
10038  FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
10039  SecondDiffType =
10040  SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
10041 
10042  break;
10043  }
10044 
10045  if (FirstDiffType == Other || SecondDiffType == Other) {
10046  // Reaching this point means an unexpected Decl was encountered
10047  // or no difference was detected. This causes a generic error
10048  // message to be emitted.
10049  Diag(FirstRecord->getLocation(),
10050  diag::err_module_odr_violation_different_definitions)
10051  << FirstRecord << FirstModule.empty() << FirstModule;
10052 
10053  if (FirstDecl) {
10054  Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
10055  << FirstRecord << FirstDecl->getSourceRange();
10056  }
10057 
10058  Diag(SecondRecord->getLocation(),
10059  diag::note_module_odr_violation_different_definitions)
10060  << SecondModule;
10061 
10062  if (SecondDecl) {
10063  Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
10064  << SecondDecl->getSourceRange();
10065  }
10066 
10067  Diagnosed = true;
10068  break;
10069  }
10070 
10071  if (FirstDiffType != SecondDiffType) {
10072  SourceLocation FirstLoc;
10073  SourceRange FirstRange;
10074  if (FirstDiffType == EndOfClass) {
10075  FirstLoc = FirstRecord->getBraceRange().getEnd();
10076  } else {
10077  FirstLoc = FirstIt->first->getLocation();
10078  FirstRange = FirstIt->first->getSourceRange();
10079  }
10080  Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
10081  << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
10082  << FirstDiffType;
10083 
10084  SourceLocation SecondLoc;
10085  SourceRange SecondRange;
10086  if (SecondDiffType == EndOfClass) {
10087  SecondLoc = SecondRecord->getBraceRange().getEnd();
10088  } else {
10089  SecondLoc = SecondDecl->getLocation();
10090  SecondRange = SecondDecl->getSourceRange();
10091  }
10092  Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10093  << SecondModule << SecondRange << SecondDiffType;
10094  Diagnosed = true;
10095  break;
10096  }
10097 
10098  assert(FirstDiffType == SecondDiffType);
10099 
10100  // Used with err_module_odr_violation_mismatch_decl_diff and
10101  // note_module_odr_violation_mismatch_decl_diff
10102  enum ODRDeclDifference {
10103  StaticAssertCondition,
10104  StaticAssertMessage,
10105  StaticAssertOnlyMessage,
10106  FieldName,
10107  FieldTypeName,
10108  FieldSingleBitField,
10109  FieldDifferentWidthBitField,
10110  FieldSingleMutable,
10111  FieldSingleInitializer,
10112  FieldDifferentInitializers,
10113  MethodName,
10114  MethodDeleted,
10115  MethodDefaulted,
10116  MethodVirtual,
10117  MethodStatic,
10118  MethodVolatile,
10119  MethodConst,
10120  MethodInline,
10121  MethodNumberParameters,
10122  MethodParameterType,
10123  MethodParameterName,
10124  MethodParameterSingleDefaultArgument,
10125  MethodParameterDifferentDefaultArgument,
10126  MethodNoTemplateArguments,
10127  MethodDifferentNumberTemplateArguments,
10128  MethodDifferentTemplateArgument,
10129  MethodSingleBody,
10130  MethodDifferentBody,
10131  TypedefName,
10132  TypedefType,
10133  VarName,
10134  VarType,
10135  VarSingleInitializer,
10136  VarDifferentInitializer,
10137  VarConstexpr,
10138  FriendTypeFunction,
10139  FriendType,
10140  FriendFunction,
10141  FunctionTemplateDifferentNumberParameters,
10142  FunctionTemplateParameterDifferentKind,
10143  FunctionTemplateParameterName,
10144  FunctionTemplateParameterSingleDefaultArgument,
10145  FunctionTemplateParameterDifferentDefaultArgument,
10146  FunctionTemplateParameterDifferentType,
10147  FunctionTemplatePackParameter,
10148  };
10149 
10150  // These lambdas have the common portions of the ODR diagnostics. This
10151  // has the same return as Diag(), so addition parameters can be passed
10152  // in with operator<<
10153  auto ODRDiagError = [FirstRecord, &FirstModule, this](
10154  SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10155  return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
10156  << FirstRecord << FirstModule.empty() << FirstModule << Range
10157  << DiffType;
10158  };
10159  auto ODRDiagNote = [&SecondModule, this](
10160  SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10161  return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
10162  << SecondModule << Range << DiffType;
10163  };
10164 
10165  switch (FirstDiffType) {
10166  case Other:
10167  case EndOfClass:
10168  case PublicSpecifer:
10169  case PrivateSpecifer:
10170  case ProtectedSpecifer:
10171  llvm_unreachable("Invalid diff type");
10172 
10173  case StaticAssert: {
10174  StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10175  StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10176 
10177  Expr *FirstExpr = FirstSA->getAssertExpr();
10178  Expr *SecondExpr = SecondSA->getAssertExpr();
10179  unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10180  unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10181  if (FirstODRHash != SecondODRHash) {
10182  ODRDiagError(FirstExpr->getLocStart(), FirstExpr->getSourceRange(),
10183  StaticAssertCondition);
10184  ODRDiagNote(SecondExpr->getLocStart(),
10185  SecondExpr->getSourceRange(), StaticAssertCondition);
10186  Diagnosed = true;
10187  break;
10188  }
10189 
10190  StringLiteral *FirstStr = FirstSA->getMessage();
10191  StringLiteral *SecondStr = SecondSA->getMessage();
10192  assert((FirstStr || SecondStr) && "Both messages cannot be empty");
10193  if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10194  SourceLocation FirstLoc, SecondLoc;
10195  SourceRange FirstRange, SecondRange;
10196  if (FirstStr) {
10197  FirstLoc = FirstStr->getLocStart();
10198  FirstRange = FirstStr->getSourceRange();
10199  } else {
10200  FirstLoc = FirstSA->getLocStart();
10201  FirstRange = FirstSA->getSourceRange();
10202  }
10203  if (SecondStr) {
10204  SecondLoc = SecondStr->getLocStart();
10205  SecondRange = SecondStr->getSourceRange();
10206  } else {
10207  SecondLoc = SecondSA->getLocStart();
10208  SecondRange = SecondSA->getSourceRange();
10209  }
10210  ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
10211  << (FirstStr == nullptr);
10212  ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
10213  << (SecondStr == nullptr);
10214  Diagnosed = true;
10215  break;
10216  }
10217 
10218  if (FirstStr && SecondStr &&
10219  FirstStr->getString() != SecondStr->getString()) {
10220  ODRDiagError(FirstStr->getLocStart(), FirstStr->getSourceRange(),
10221  StaticAssertMessage);
10222  ODRDiagNote(SecondStr->getLocStart(), SecondStr->getSourceRange(),
10223  StaticAssertMessage);
10224  Diagnosed = true;
10225  break;
10226  }
10227  break;
10228  }
10229  case Field: {
10230  FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
10231  FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
10232  IdentifierInfo *FirstII = FirstField->getIdentifier();
10233  IdentifierInfo *SecondII = SecondField->getIdentifier();
10234  if (FirstII->getName() != SecondII->getName()) {
10235  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10236  FieldName)
10237  << FirstII;
10238  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10239  FieldName)
10240  << SecondII;
10241 
10242  Diagnosed = true;
10243  break;
10244  }
10245 
10246  assert(getContext().hasSameType(FirstField->getType(),
10247  SecondField->getType()));
10248 
10249  QualType FirstType = FirstField->getType();
10250  QualType SecondType = SecondField->getType();
10251  if (ComputeQualTypeODRHash(FirstType) !=
10252  ComputeQualTypeODRHash(SecondType)) {
10253  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10254  FieldTypeName)
10255  << FirstII << FirstType;
10256  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10257  FieldTypeName)
10258  << SecondII << SecondType;
10259 
10260  Diagnosed = true;
10261  break;
10262  }
10263 
10264  const bool IsFirstBitField = FirstField->isBitField();
10265  const bool IsSecondBitField = SecondField->isBitField();
10266  if (IsFirstBitField != IsSecondBitField) {
10267  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10268  FieldSingleBitField)
10269  << FirstII << IsFirstBitField;
10270  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10271  FieldSingleBitField)
10272  << SecondII << IsSecondBitField;
10273  Diagnosed = true;
10274  break;
10275  }
10276 
10277  if (IsFirstBitField && IsSecondBitField) {
10278  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10279  FieldDifferentWidthBitField)
10280  << FirstII << FirstField->getBitWidth()->getSourceRange();
10281  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10282  FieldDifferentWidthBitField)
10283  << SecondII << SecondField->getBitWidth()->getSourceRange();
10284  Diagnosed = true;
10285  break;
10286  }
10287 
10288  const bool IsFirstMutable = FirstField->isMutable();
10289  const bool IsSecondMutable = SecondField->isMutable();
10290  if (IsFirstMutable != IsSecondMutable) {
10291  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10292  FieldSingleMutable)
10293  << FirstII << IsFirstMutable;
10294  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10295  FieldSingleMutable)
10296  << SecondII << IsSecondMutable;
10297  Diagnosed = true;
10298  break;
10299  }
10300 
10301  const Expr *FirstInitializer = FirstField->getInClassInitializer();
10302  const Expr *SecondInitializer = SecondField->getInClassInitializer();
10303  if ((!FirstInitializer && SecondInitializer) ||
10304  (FirstInitializer && !SecondInitializer)) {
10305  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10306  FieldSingleInitializer)
10307  << FirstII << (FirstInitializer != nullptr);
10308  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10309  FieldSingleInitializer)
10310  << SecondII << (SecondInitializer != nullptr);
10311  Diagnosed = true;
10312  break;
10313  }
10314 
10315  if (FirstInitializer && SecondInitializer) {
10316  unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
10317  unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
10318  if (FirstInitHash != SecondInitHash) {
10319  ODRDiagError(FirstField->getLocation(),
10320  FirstField->getSourceRange(),
10321  FieldDifferentInitializers)
10322  << FirstII << FirstInitializer->getSourceRange();
10323  ODRDiagNote(SecondField->getLocation(),
10324  SecondField->getSourceRange(),
10325  FieldDifferentInitializers)
10326  << SecondII << SecondInitializer->getSourceRange();
10327  Diagnosed = true;
10328  break;
10329  }
10330  }
10331 
10332  break;
10333  }
10334  case CXXMethod: {
10335  enum {
10336  DiagMethod,
10337  DiagConstructor,
10338  DiagDestructor,
10339  } FirstMethodType,
10340  SecondMethodType;
10341  auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10342  if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10343  if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10344  return DiagMethod;
10345  };
10346  const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10347  const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10348  FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10349  SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10350  auto FirstName = FirstMethod->getDeclName();
10351  auto SecondName = SecondMethod->getDeclName();
10352  if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10353  ODRDiagError(FirstMethod->getLocation(),
10354  FirstMethod->getSourceRange(), MethodName)
10355  << FirstMethodType << FirstName;
10356  ODRDiagNote(SecondMethod->getLocation(),
10357  SecondMethod->getSourceRange(), MethodName)
10358  << SecondMethodType << SecondName;
10359 
10360  Diagnosed = true;
10361  break;
10362  }
10363 
10364  const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10365  const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10366  if (FirstDeleted != SecondDeleted) {
10367  ODRDiagError(FirstMethod->getLocation(),
10368  FirstMethod->getSourceRange(), MethodDeleted)
10369  << FirstMethodType << FirstName << FirstDeleted;
10370 
10371  ODRDiagNote(SecondMethod->getLocation(),
10372  SecondMethod->getSourceRange(), MethodDeleted)
10373  << SecondMethodType << SecondName << SecondDeleted;
10374  Diagnosed = true;
10375  break;
10376  }
10377 
10378  const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10379  const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10380  if (FirstDefaulted != SecondDefaulted) {
10381  ODRDiagError(FirstMethod->getLocation(),
10382  FirstMethod->getSourceRange(), MethodDefaulted)
10383  << FirstMethodType << FirstName << FirstDefaulted;
10384 
10385  ODRDiagNote(SecondMethod->getLocation(),
10386  SecondMethod->getSourceRange(), MethodDefaulted)
10387  << SecondMethodType << SecondName << SecondDefaulted;
10388  Diagnosed = true;
10389  break;
10390  }
10391 
10392  const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10393  const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10394  const bool FirstPure = FirstMethod->isPure();
10395  const bool SecondPure = SecondMethod->isPure();
10396  if ((FirstVirtual || SecondVirtual) &&
10397  (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10398  ODRDiagError(FirstMethod->getLocation(),
10399  FirstMethod->getSourceRange(), MethodVirtual)
10400  << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10401  ODRDiagNote(SecondMethod->getLocation(),
10402  SecondMethod->getSourceRange(), MethodVirtual)
10403  << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10404  Diagnosed = true;
10405  break;
10406  }
10407 
10408  // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10409  // FirstDecl is the canonical Decl of SecondDecl, so the storage
10410  // class needs to be checked instead.
10411  const auto FirstStorage = FirstMethod->getStorageClass();
10412  const auto SecondStorage = SecondMethod->getStorageClass();
10413  const bool FirstStatic = FirstStorage == SC_Static;
10414  const bool SecondStatic = SecondStorage == SC_Static;
10415  if (FirstStatic != SecondStatic) {
10416  ODRDiagError(FirstMethod->getLocation(),
10417  FirstMethod->getSourceRange(), MethodStatic)
10418  << FirstMethodType << FirstName << FirstStatic;
10419  ODRDiagNote(SecondMethod->getLocation(),
10420  SecondMethod->getSourceRange(), MethodStatic)
10421  << SecondMethodType << SecondName << SecondStatic;
10422  Diagnosed = true;
10423  break;
10424  }
10425 
10426  const bool FirstVolatile = FirstMethod->isVolatile();
10427  const bool SecondVolatile = SecondMethod->isVolatile();
10428  if (FirstVolatile != SecondVolatile) {
10429  ODRDiagError(FirstMethod->getLocation(),
10430  FirstMethod->getSourceRange(), MethodVolatile)
10431  << FirstMethodType << FirstName << FirstVolatile;
10432  ODRDiagNote(SecondMethod->getLocation(),
10433  SecondMethod->getSourceRange(), MethodVolatile)
10434  << SecondMethodType << SecondName << SecondVolatile;
10435  Diagnosed = true;
10436  break;
10437  }
10438 
10439  const bool FirstConst = FirstMethod->isConst();
10440  const bool SecondConst = SecondMethod->isConst();
10441  if (FirstConst != SecondConst) {
10442  ODRDiagError(FirstMethod->getLocation(),
10443  FirstMethod->getSourceRange(), MethodConst)
10444  << FirstMethodType << FirstName << FirstConst;
10445  ODRDiagNote(SecondMethod->getLocation(),
10446  SecondMethod->getSourceRange(), MethodConst)
10447  << SecondMethodType << SecondName << SecondConst;
10448  Diagnosed = true;
10449  break;
10450  }
10451 
10452  const bool FirstInline = FirstMethod->isInlineSpecified();
10453  const bool SecondInline = SecondMethod->isInlineSpecified();
10454  if (FirstInline != SecondInline) {
10455  ODRDiagError(FirstMethod->getLocation(),
10456  FirstMethod->getSourceRange(), MethodInline)
10457  << FirstMethodType << FirstName << FirstInline;
10458  ODRDiagNote(SecondMethod->getLocation(),
10459  SecondMethod->getSourceRange(), MethodInline)
10460  << SecondMethodType << SecondName << SecondInline;
10461  Diagnosed = true;
10462  break;
10463  }
10464 
10465  const unsigned FirstNumParameters = FirstMethod->param_size();
10466  const unsigned SecondNumParameters = SecondMethod->param_size();
10467  if (FirstNumParameters != SecondNumParameters) {
10468  ODRDiagError(FirstMethod->getLocation(),
10469  FirstMethod->getSourceRange(), MethodNumberParameters)
10470  << FirstMethodType << FirstName << FirstNumParameters;
10471  ODRDiagNote(SecondMethod->getLocation(),
10472  SecondMethod->getSourceRange(), MethodNumberParameters)
10473  << SecondMethodType << SecondName << SecondNumParameters;
10474  Diagnosed = true;
10475  break;
10476  }
10477 
10478  // Need this status boolean to know when break out of the switch.
10479  bool ParameterMismatch = false;
10480  for (unsigned I = 0; I < FirstNumParameters; ++I) {
10481  const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10482  const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10483 
10484  QualType FirstParamType = FirstParam->getType();
10485  QualType SecondParamType = SecondParam->getType();
10486  if (FirstParamType != SecondParamType &&
10487  ComputeQualTypeODRHash(FirstParamType) !=
10488  ComputeQualTypeODRHash(SecondParamType)) {
10489  if (const DecayedType *ParamDecayedType =
10490  FirstParamType->getAs<DecayedType>()) {
10491  ODRDiagError(FirstMethod->getLocation(),
10492  FirstMethod->getSourceRange(), MethodParameterType)
10493  << FirstMethodType << FirstName << (I + 1) << FirstParamType
10494  << true << ParamDecayedType->getOriginalType();
10495  } else {
10496  ODRDiagError(FirstMethod->getLocation(),
10497  FirstMethod->getSourceRange(), MethodParameterType)
10498  << FirstMethodType << FirstName << (I + 1) << FirstParamType
10499  << false;
10500  }
10501 
10502  if (const DecayedType *ParamDecayedType =
10503  SecondParamType->getAs<DecayedType>()) {
10504  ODRDiagNote(SecondMethod->getLocation(),
10505  SecondMethod->getSourceRange(), MethodParameterType)
10506  << SecondMethodType << SecondName << (I + 1)
10507  << SecondParamType << true
10508  << ParamDecayedType->getOriginalType();
10509  } else {
10510  ODRDiagNote(SecondMethod->getLocation(),
10511  SecondMethod->getSourceRange(), MethodParameterType)
10512  << SecondMethodType << SecondName << (I + 1)
10513  << SecondParamType << false;
10514  }
10515  ParameterMismatch = true;
10516  break;
10517  }
10518 
10519  DeclarationName FirstParamName = FirstParam->getDeclName();
10520  DeclarationName SecondParamName = SecondParam->getDeclName();
10521  if (FirstParamName != SecondParamName) {
10522  ODRDiagError(FirstMethod->getLocation(),
10523  FirstMethod->getSourceRange(), MethodParameterName)
10524  << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10525  ODRDiagNote(SecondMethod->getLocation(),
10526  SecondMethod->getSourceRange(), MethodParameterName)
10527  << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10528  ParameterMismatch = true;
10529  break;
10530  }
10531 
10532  const Expr *FirstInit = FirstParam->getInit();
10533  const Expr *SecondInit = SecondParam->getInit();
10534  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10535  ODRDiagError(FirstMethod->getLocation(),
10536  FirstMethod->getSourceRange(),
10537  MethodParameterSingleDefaultArgument)
10538  << FirstMethodType << FirstName << (I + 1)
10539  << (FirstInit == nullptr)
10540  << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10541  ODRDiagNote(SecondMethod->getLocation(),
10542  SecondMethod->getSourceRange(),
10543  MethodParameterSingleDefaultArgument)
10544  << SecondMethodType << SecondName << (I + 1)
10545  << (SecondInit == nullptr)
10546  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10547  ParameterMismatch = true;
10548  break;
10549  }
10550 
10551  if (FirstInit && SecondInit &&
10552  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10553  ODRDiagError(FirstMethod->getLocation(),
10554  FirstMethod->getSourceRange(),
10555  MethodParameterDifferentDefaultArgument)
10556  << FirstMethodType << FirstName << (I + 1)
10557  << FirstInit->getSourceRange();
10558  ODRDiagNote(SecondMethod->getLocation(),
10559  SecondMethod->getSourceRange(),
10560  MethodParameterDifferentDefaultArgument)
10561  << SecondMethodType << SecondName << (I + 1)
10562  << SecondInit->getSourceRange();
10563  ParameterMismatch = true;
10564  break;
10565 
10566  }
10567  }
10568 
10569  if (ParameterMismatch) {
10570  Diagnosed = true;
10571  break;
10572  }
10573 
10574  const auto *FirstTemplateArgs =
10575  FirstMethod->getTemplateSpecializationArgs();
10576  const auto *SecondTemplateArgs =
10577  SecondMethod->getTemplateSpecializationArgs();
10578 
10579  if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10580  (!FirstTemplateArgs && SecondTemplateArgs)) {
10581  ODRDiagError(FirstMethod->getLocation(),
10582  FirstMethod->getSourceRange(), MethodNoTemplateArguments)
10583  << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10584  ODRDiagNote(SecondMethod->getLocation(),
10585  SecondMethod->getSourceRange(), MethodNoTemplateArguments)
10586  << SecondMethodType << SecondName
10587  << (SecondTemplateArgs != nullptr);
10588 
10589  Diagnosed = true;
10590  break;
10591  }
10592 
10593  if (FirstTemplateArgs && SecondTemplateArgs) {
10594  // Remove pack expansions from argument list.
10595  auto ExpandTemplateArgumentList =
10596  [](const TemplateArgumentList *TAL) {
10598  for (const TemplateArgument &TA : TAL->asArray()) {
10599  if (TA.getKind() != TemplateArgument::Pack) {
10600  ExpandedList.push_back(&TA);
10601  continue;
10602  }
10603  for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10604  ExpandedList.push_back(&PackTA);
10605  }
10606  }
10607  return ExpandedList;
10608  };
10610  ExpandTemplateArgumentList(FirstTemplateArgs);
10612  ExpandTemplateArgumentList(SecondTemplateArgs);
10613 
10614  if (FirstExpandedList.size() != SecondExpandedList.size()) {
10615  ODRDiagError(FirstMethod->getLocation(),
10616  FirstMethod->getSourceRange(),
10617  MethodDifferentNumberTemplateArguments)
10618  << FirstMethodType << FirstName
10619  << (unsigned)FirstExpandedList.size();
10620  ODRDiagNote(SecondMethod->getLocation(),
10621  SecondMethod->getSourceRange(),
10622  MethodDifferentNumberTemplateArguments)
10623  << SecondMethodType << SecondName
10624  << (unsigned)SecondExpandedList.size();
10625 
10626  Diagnosed = true;
10627  break;
10628  }
10629 
10630  bool TemplateArgumentMismatch = false;
10631  for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10632  const TemplateArgument &FirstTA = *FirstExpandedList[i],
10633  &SecondTA = *SecondExpandedList[i];
10634  if (ComputeTemplateArgumentODRHash(FirstTA) ==
10635  ComputeTemplateArgumentODRHash(SecondTA)) {
10636  continue;
10637  }
10638 
10639  ODRDiagError(FirstMethod->getLocation(),
10640  FirstMethod->getSourceRange(),
10641  MethodDifferentTemplateArgument)
10642  << FirstMethodType << FirstName << FirstTA << i + 1;
10643  ODRDiagNote(SecondMethod->getLocation(),
10644  SecondMethod->getSourceRange(),
10645  MethodDifferentTemplateArgument)
10646  << SecondMethodType << SecondName << SecondTA << i + 1;
10647 
10648  TemplateArgumentMismatch = true;
10649  break;
10650  }
10651 
10652  if (TemplateArgumentMismatch) {
10653  Diagnosed = true;
10654  break;
10655  }
10656  }
10657 
10658  // Compute the hash of the method as if it has no body.
10659  auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10660  Hash.clear();
10661  Hash.AddFunctionDecl(D, true /*SkipBody*/);
10662  return Hash.CalculateHash();
10663  };
10664 
10665  // Compare the hash generated to the hash stored. A difference means
10666  // that a body was present in the original source. Due to merging,
10667  // the stardard way of detecting a body will not work.
10668  const bool HasFirstBody =
10669  ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10670  const bool HasSecondBody =
10671  ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10672 
10673  if (HasFirstBody != HasSecondBody) {
10674  ODRDiagError(FirstMethod->getLocation(),
10675  FirstMethod->getSourceRange(), MethodSingleBody)
10676  << FirstMethodType << FirstName << HasFirstBody;
10677  ODRDiagNote(SecondMethod->getLocation(),
10678  SecondMethod->getSourceRange(), MethodSingleBody)
10679  << SecondMethodType << SecondName << HasSecondBody;
10680  Diagnosed = true;
10681  break;
10682  }
10683 
10684  if (HasFirstBody && HasSecondBody) {
10685  ODRDiagError(FirstMethod->getLocation(),
10686  FirstMethod->getSourceRange(), MethodDifferentBody)
10687  << FirstMethodType << FirstName;
10688  ODRDiagNote(SecondMethod->getLocation(),
10689  SecondMethod->getSourceRange(), MethodDifferentBody)
10690  << SecondMethodType << SecondName;
10691  Diagnosed = true;
10692  break;
10693  }
10694 
10695  break;
10696  }
10697  case TypeAlias:
10698  case TypeDef: {
10699  TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
10700  TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
10701  auto FirstName = FirstTD->getDeclName();
10702  auto SecondName = SecondTD->getDeclName();
10703  if (FirstName != SecondName) {
10704  ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10705  TypedefName)
10706  << (FirstDiffType == TypeAlias) << FirstName;
10707  ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10708  TypedefName)
10709  << (FirstDiffType == TypeAlias) << SecondName;
10710  Diagnosed = true;
10711  break;
10712  }
10713 
10714  QualType FirstType = FirstTD->getUnderlyingType();
10715  QualType SecondType = SecondTD->getUnderlyingType();
10716  if (ComputeQualTypeODRHash(FirstType) !=
10717  ComputeQualTypeODRHash(SecondType)) {
10718  ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10719  TypedefType)
10720  << (FirstDiffType == TypeAlias) << FirstName << FirstType;
10721  ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10722  TypedefType)
10723  << (FirstDiffType == TypeAlias) << SecondName << SecondType;
10724  Diagnosed = true;
10725  break;
10726  }
10727  break;
10728  }
10729  case Var: {
10730  VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
10731  VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
10732  auto FirstName = FirstVD->getDeclName();
10733  auto SecondName = SecondVD->getDeclName();
10734  if (FirstName != SecondName) {
10735  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10736  VarName)
10737  << FirstName;
10738  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10739  VarName)
10740  << SecondName;
10741  Diagnosed = true;
10742  break;
10743  }
10744 
10745  QualType FirstType = FirstVD->getType();
10746  QualType SecondType = SecondVD->getType();
10747  if (ComputeQualTypeODRHash(FirstType) !=
10748  ComputeQualTypeODRHash(SecondType)) {
10749  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10750  VarType)
10751  << FirstName << FirstType;
10752  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10753  VarType)
10754  << SecondName << SecondType;
10755  Diagnosed = true;
10756  break;
10757  }
10758 
10759  const Expr *FirstInit = FirstVD->getInit();
10760  const Expr *SecondInit = SecondVD->getInit();
10761  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10762  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10763  VarSingleInitializer)
10764  << FirstName << (FirstInit == nullptr)
10765  << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
10766  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10767  VarSingleInitializer)
10768  << SecondName << (SecondInit == nullptr)
10769  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10770  Diagnosed = true;
10771  break;
10772  }
10773 
10774  if (FirstInit && SecondInit &&
10775  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10776  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10777  VarDifferentInitializer)
10778  << FirstName << FirstInit->getSourceRange();
10779  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10780  VarDifferentInitializer)
10781  << SecondName << SecondInit->getSourceRange();
10782  Diagnosed = true;
10783  break;
10784  }
10785 
10786  const bool FirstIsConstexpr = FirstVD->isConstexpr();
10787  const bool SecondIsConstexpr = SecondVD->isConstexpr();
10788  if (FirstIsConstexpr != SecondIsConstexpr) {
10789  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10790  VarConstexpr)
10791  << FirstName << FirstIsConstexpr;
10792  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10793  VarConstexpr)
10794  << SecondName << SecondIsConstexpr;
10795  Diagnosed = true;
10796  break;
10797  }
10798  break;
10799  }
10800  case Friend: {
10801  FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10802  FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10803 
10804  NamedDecl *FirstND = FirstFriend->getFriendDecl();
10805  NamedDecl *SecondND = SecondFriend->getFriendDecl();
10806 
10807  TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10808  TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10809 
10810  if (FirstND && SecondND) {
10811  ODRDiagError(FirstFriend->getFriendLoc(),
10812  FirstFriend->getSourceRange(), FriendFunction)
10813  << FirstND;
10814  ODRDiagNote(SecondFriend->getFriendLoc(),
10815  SecondFriend->getSourceRange(), FriendFunction)
10816  << SecondND;
10817 
10818  Diagnosed = true;
10819  break;
10820  }
10821 
10822  if (FirstTSI && SecondTSI) {
10823  QualType FirstFriendType = FirstTSI->getType();
10824  QualType SecondFriendType = SecondTSI->getType();
10825  assert(ComputeQualTypeODRHash(FirstFriendType) !=
10826  ComputeQualTypeODRHash(SecondFriendType));
10827  ODRDiagError(FirstFriend->getFriendLoc(),
10828  FirstFriend->getSourceRange(), FriendType)
10829  << FirstFriendType;
10830  ODRDiagNote(SecondFriend->getFriendLoc(),
10831  SecondFriend->getSourceRange(), FriendType)
10832  << SecondFriendType;
10833  Diagnosed = true;
10834  break;
10835  }
10836 
10837  ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10838  FriendTypeFunction)
10839  << (FirstTSI == nullptr);
10840  ODRDiagNote(SecondFriend->getFriendLoc(),
10841  SecondFriend->getSourceRange(), FriendTypeFunction)
10842  << (SecondTSI == nullptr);
10843 
10844  Diagnosed = true;
10845  break;
10846  }
10847  case FunctionTemplate: {
10848  FunctionTemplateDecl *FirstTemplate =
10849  cast<FunctionTemplateDecl>(FirstDecl);
10850  FunctionTemplateDecl *SecondTemplate =
10851  cast<FunctionTemplateDecl>(SecondDecl);
10852 
10853  TemplateParameterList *FirstTPL =
10854  FirstTemplate->getTemplateParameters();
10855  TemplateParameterList *SecondTPL =
10856  SecondTemplate->getTemplateParameters();
10857 
10858  if (FirstTPL->size() != SecondTPL->size()) {
10859  ODRDiagError(FirstTemplate->getLocation(),
10860  FirstTemplate->getSourceRange(),
10861  FunctionTemplateDifferentNumberParameters)
10862  << FirstTemplate << FirstTPL->size();
10863  ODRDiagNote(SecondTemplate->getLocation(),
10864  SecondTemplate->getSourceRange(),
10865  FunctionTemplateDifferentNumberParameters)
10866  << SecondTemplate << SecondTPL->size();
10867 
10868  Diagnosed = true;
10869  break;
10870  }
10871 
10872  bool ParameterMismatch = false;
10873  for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10874  NamedDecl *FirstParam = FirstTPL->getParam(i);
10875  NamedDecl *SecondParam = SecondTPL->getParam(i);
10876 
10877  if (FirstParam->getKind() != SecondParam->getKind()) {
10878  enum {
10879  TemplateTypeParameter,
10880  NonTypeTemplateParameter,
10881  TemplateTemplateParameter,
10882  };
10883  auto GetParamType = [](NamedDecl *D) {
10884  switch (D->getKind()) {
10885  default:
10886  llvm_unreachable("Unexpected template parameter type");
10887  case Decl::TemplateTypeParm:
10888  return TemplateTypeParameter;
10889  case Decl::NonTypeTemplateParm:
10890  return NonTypeTemplateParameter;
10891  case Decl::TemplateTemplateParm:
10892  return TemplateTemplateParameter;
10893  }
10894  };
10895 
10896  ODRDiagError(FirstTemplate->getLocation(),
10897  FirstTemplate->getSourceRange(),
10898  FunctionTemplateParameterDifferentKind)
10899  << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10900  ODRDiagNote(SecondTemplate->getLocation(),
10901  SecondTemplate->getSourceRange(),
10902  FunctionTemplateParameterDifferentKind)
10903  << SecondTemplate << (i + 1) << GetParamType(SecondParam);
10904 
10905  ParameterMismatch = true;
10906  break;
10907  }
10908 
10909  if (FirstParam->getName() != SecondParam->getName()) {
10910  ODRDiagError(FirstTemplate->getLocation(),
10911  FirstTemplate->getSourceRange(),
10912  FunctionTemplateParameterName)
10913  << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
10914  << FirstParam;
10915  ODRDiagNote(SecondTemplate->getLocation(),
10916  SecondTemplate->getSourceRange(),
10917  FunctionTemplateParameterName)
10918  << SecondTemplate << (i + 1)
10919  << (bool)SecondParam->getIdentifier() << SecondParam;
10920  ParameterMismatch = true;
10921  break;
10922  }
10923 
10924  if (isa<TemplateTypeParmDecl>(FirstParam) &&
10925  isa<TemplateTypeParmDecl>(SecondParam)) {
10926  TemplateTypeParmDecl *FirstTTPD =
10927  cast<TemplateTypeParmDecl>(FirstParam);
10928  TemplateTypeParmDecl *SecondTTPD =
10929  cast<TemplateTypeParmDecl>(SecondParam);
10930  bool HasFirstDefaultArgument =
10931  FirstTTPD->hasDefaultArgument() &&
10932  !FirstTTPD->defaultArgumentWasInherited();
10933  bool HasSecondDefaultArgument =
10934  SecondTTPD->hasDefaultArgument() &&
10935  !SecondTTPD->defaultArgumentWasInherited();
10936  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10937  ODRDiagError(FirstTemplate->getLocation(),
10938  FirstTemplate->getSourceRange(),
10939  FunctionTemplateParameterSingleDefaultArgument)
10940  << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
10941  ODRDiagNote(SecondTemplate->getLocation(),
10942  SecondTemplate->getSourceRange(),
10943  FunctionTemplateParameterSingleDefaultArgument)
10944  << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
10945  ParameterMismatch = true;
10946  break;
10947  }
10948 
10949  if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
10950  QualType FirstType = FirstTTPD->getDefaultArgument();
10951  QualType SecondType = SecondTTPD->getDefaultArgument();
10952  if (ComputeQualTypeODRHash(FirstType) !=
10953  ComputeQualTypeODRHash(SecondType)) {
10954  ODRDiagError(FirstTemplate->getLocation(),
10955  FirstTemplate->getSourceRange(),
10956  FunctionTemplateParameterDifferentDefaultArgument)
10957  << FirstTemplate << (i + 1) << FirstType;
10958  ODRDiagNote(SecondTemplate->getLocation(),
10959  SecondTemplate->getSourceRange(),
10960  FunctionTemplateParameterDifferentDefaultArgument)
10961  << SecondTemplate << (i + 1) << SecondType;
10962  ParameterMismatch = true;
10963  break;
10964  }
10965  }
10966 
10967  if (FirstTTPD->isParameterPack() !=
10968  SecondTTPD->isParameterPack()) {
10969  ODRDiagError(FirstTemplate->getLocation(),
10970  FirstTemplate->getSourceRange(),
10971  FunctionTemplatePackParameter)
10972  << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
10973  ODRDiagNote(SecondTemplate->getLocation(),
10974  SecondTemplate->getSourceRange(),
10975  FunctionTemplatePackParameter)
10976  << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
10977  ParameterMismatch = true;
10978  break;
10979  }
10980  }
10981 
10982  if (isa<TemplateTemplateParmDecl>(FirstParam) &&
10983  isa<TemplateTemplateParmDecl>(SecondParam)) {
10984  TemplateTemplateParmDecl *FirstTTPD =
10985  cast<TemplateTemplateParmDecl>(FirstParam);
10986  TemplateTemplateParmDecl *SecondTTPD =
10987  cast<TemplateTemplateParmDecl>(SecondParam);
10988 
10989  TemplateParameterList *FirstTPL =
10990  FirstTTPD->getTemplateParameters();
10991  TemplateParameterList *SecondTPL =
10992  SecondTTPD->getTemplateParameters();
10993 
10994  if (ComputeTemplateParameterListODRHash(FirstTPL) !=
10995  ComputeTemplateParameterListODRHash(SecondTPL)) {
10996  ODRDiagError(FirstTemplate->getLocation(),
10997  FirstTemplate->getSourceRange(),
10998  FunctionTemplateParameterDifferentType)
10999  << FirstTemplate << (i + 1);
11000  ODRDiagNote(SecondTemplate->getLocation(),
11001  SecondTemplate->getSourceRange(),
11002  FunctionTemplateParameterDifferentType)
11003  << SecondTemplate << (i + 1);
11004  ParameterMismatch = true;
11005  break;
11006  }
11007 
11008  bool HasFirstDefaultArgument =
11009  FirstTTPD->hasDefaultArgument() &&
11010  !FirstTTPD->defaultArgumentWasInherited();
11011  bool HasSecondDefaultArgument =
11012  SecondTTPD->hasDefaultArgument() &&
11013  !SecondTTPD->defaultArgumentWasInherited();
11014  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11015  ODRDiagError(FirstTemplate->getLocation(),
11016  FirstTemplate->getSourceRange(),
11017  FunctionTemplateParameterSingleDefaultArgument)
11018  << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11019  ODRDiagNote(SecondTemplate->getLocation(),
11020  SecondTemplate->getSourceRange(),
11021  FunctionTemplateParameterSingleDefaultArgument)
11022  << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11023  ParameterMismatch = true;
11024  break;
11025  }
11026 
11027  if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11028  TemplateArgument FirstTA =
11029  FirstTTPD->getDefaultArgument().getArgument();
11030  TemplateArgument SecondTA =
11031  SecondTTPD->getDefaultArgument().getArgument();
11032  if (ComputeTemplateArgumentODRHash(FirstTA) !=
11033  ComputeTemplateArgumentODRHash(SecondTA)) {
11034  ODRDiagError(FirstTemplate->getLocation(),
11035  FirstTemplate->getSourceRange(),
11036  FunctionTemplateParameterDifferentDefaultArgument)
11037  << FirstTemplate << (i + 1) << FirstTA;
11038  ODRDiagNote(SecondTemplate->getLocation(),
11039  SecondTemplate->getSourceRange(),
11040  FunctionTemplateParameterDifferentDefaultArgument)
11041  << SecondTemplate << (i + 1) << SecondTA;
11042  ParameterMismatch = true;
11043  break;
11044  }
11045  }
11046 
11047  if (FirstTTPD->isParameterPack() !=
11048  SecondTTPD->isParameterPack()) {
11049  ODRDiagError(FirstTemplate->getLocation(),
11050  FirstTemplate->getSourceRange(),
11051  FunctionTemplatePackParameter)
11052  << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11053  ODRDiagNote(SecondTemplate->getLocation(),
11054  SecondTemplate->getSourceRange(),
11055  FunctionTemplatePackParameter)
11056  << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11057  ParameterMismatch = true;
11058  break;
11059  }
11060  }
11061 
11062  if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11063  isa<NonTypeTemplateParmDecl>(SecondParam)) {
11064  NonTypeTemplateParmDecl *FirstNTTPD =
11065  cast<NonTypeTemplateParmDecl>(FirstParam);
11066  NonTypeTemplateParmDecl *SecondNTTPD =
11067  cast<NonTypeTemplateParmDecl>(SecondParam);
11068 
11069  QualType FirstType = FirstNTTPD->getType();
11070  QualType SecondType = SecondNTTPD->getType();
11071  if (ComputeQualTypeODRHash(FirstType) !=
11072  ComputeQualTypeODRHash(SecondType)) {
11073  ODRDiagError(FirstTemplate->getLocation(),
11074  FirstTemplate->getSourceRange(),
11075  FunctionTemplateParameterDifferentType)
11076  << FirstTemplate << (i + 1);
11077  ODRDiagNote(SecondTemplate->getLocation(),
11078  SecondTemplate->getSourceRange(),
11079  FunctionTemplateParameterDifferentType)
11080  << SecondTemplate << (i + 1);
11081  ParameterMismatch = true;
11082  break;
11083  }
11084 
11085  bool HasFirstDefaultArgument =
11086  FirstNTTPD->hasDefaultArgument() &&
11087  !FirstNTTPD->defaultArgumentWasInherited();
11088  bool HasSecondDefaultArgument =
11089  SecondNTTPD->hasDefaultArgument() &&
11090  !SecondNTTPD->defaultArgumentWasInherited();
11091  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11092  ODRDiagError(FirstTemplate->getLocation(),
11093  FirstTemplate->getSourceRange(),
11094  FunctionTemplateParameterSingleDefaultArgument)
11095  << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11096  ODRDiagNote(SecondTemplate->getLocation(),
11097  SecondTemplate->getSourceRange(),
11098  FunctionTemplateParameterSingleDefaultArgument)
11099  << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11100  ParameterMismatch = true;
11101  break;
11102  }
11103 
11104  if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11105  Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11106  Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11107  if (ComputeODRHash(FirstDefaultArgument) !=
11108  ComputeODRHash(SecondDefaultArgument)) {
11109  ODRDiagError(FirstTemplate->getLocation(),
11110  FirstTemplate->getSourceRange(),
11111  FunctionTemplateParameterDifferentDefaultArgument)
11112  << FirstTemplate << (i + 1) << FirstDefaultArgument;
11113  ODRDiagNote(SecondTemplate->getLocation(),
11114  SecondTemplate->getSourceRange(),
11115  FunctionTemplateParameterDifferentDefaultArgument)
11116  << SecondTemplate << (i + 1) << SecondDefaultArgument;
11117  ParameterMismatch = true;
11118  break;
11119  }
11120  }
11121 
11122  if (FirstNTTPD->isParameterPack() !=
11123  SecondNTTPD->isParameterPack()) {
11124  ODRDiagError(FirstTemplate->getLocation(),
11125  FirstTemplate->getSourceRange(),
11126  FunctionTemplatePackParameter)
11127  << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11128  ODRDiagNote(SecondTemplate->getLocation(),
11129  SecondTemplate->getSourceRange(),
11130  FunctionTemplatePackParameter)
11131  << SecondTemplate << (i + 1)
11132  << SecondNTTPD->isParameterPack();
11133  ParameterMismatch = true;
11134  break;
11135  }
11136  }
11137  }
11138 
11139  if (ParameterMismatch) {
11140  Diagnosed = true;
11141  break;
11142  }
11143 
11144  break;
11145  }
11146  }
11147 
11148  if (Diagnosed)
11149  continue;
11150 
11151  Diag(FirstDecl->getLocation(),
11152  diag::err_module_odr_violation_mismatch_decl_unknown)
11153  << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11154  << FirstDecl->getSourceRange();
11155  Diag(SecondDecl->getLocation(),
11156  diag::note_module_odr_violation_mismatch_decl_unknown)
11157  << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11158  Diagnosed = true;
11159  }
11160 
11161  if (!Diagnosed) {
11162  // All definitions are updates to the same declaration. This happens if a
11163  // module instantiates the declaration of a class template specialization
11164  // and two or more other modules instantiate its definition.
11165  //
11166  // FIXME: Indicate which modules had instantiations of this definition.
11167  // FIXME: How can this even happen?
11168  Diag(Merge.first->getLocation(),
11169  diag::err_module_odr_violation_different_instantiations)
11170  << Merge.first;
11171  }
11172  }
11173 
11174  // Issue ODR failures diagnostics for functions.
11175  for (auto &Merge : FunctionOdrMergeFailures) {
11176  enum ODRFunctionDifference {
11177  ReturnType,
11178  ParameterName,
11179  ParameterType,
11180  ParameterSingleDefaultArgument,
11181  ParameterDifferentDefaultArgument,
11182  FunctionBody,
11183  };
11184 
11185  FunctionDecl *FirstFunction = Merge.first;
11186  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11187 
11188  bool Diagnosed = false;
11189  for (auto &SecondFunction : Merge.second) {
11190 
11191  if (FirstFunction == SecondFunction)
11192  continue;
11193 
11194  std::string SecondModule =
11195  getOwningModuleNameForDiagnostic(SecondFunction);
11196 
11197  auto ODRDiagError = [FirstFunction, &FirstModule,
11198  this](SourceLocation Loc, SourceRange Range,
11199  ODRFunctionDifference DiffType) {
11200  return Diag(Loc, diag::err_module_odr_violation_function)
11201  << FirstFunction << FirstModule.empty() << FirstModule << Range
11202  << DiffType;
11203  };
11204  auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11205  SourceRange Range,
11206  ODRFunctionDifference DiffType) {
11207  return Diag(Loc, diag::note_module_odr_violation_function)
11208  << SecondModule << Range << DiffType;
11209  };
11210 
11211  if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11212  ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11213  ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11214  FirstFunction->getReturnTypeSourceRange(), ReturnType)
11215  << FirstFunction->getReturnType();
11216  ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11217  SecondFunction->getReturnTypeSourceRange(), ReturnType)
11218  << SecondFunction->getReturnType();
11219  Diagnosed = true;
11220  break;
11221  }
11222 
11223  assert(FirstFunction->param_size() == SecondFunction->param_size() &&
11224  "Merged functions with different number of parameters");
11225 
11226  auto ParamSize = FirstFunction->param_size();
11227  bool ParameterMismatch = false;
11228  for (unsigned I = 0; I < ParamSize; ++I) {
11229  auto *FirstParam = FirstFunction->getParamDecl(I);
11230  auto *SecondParam = SecondFunction->getParamDecl(I);
11231 
11232  assert(getContext().hasSameType(FirstParam->getType(),
11233  SecondParam->getType()) &&
11234  "Merged function has different parameter types.");
11235 
11236  if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11237  ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11238  ParameterName)
11239  << I + 1 << FirstParam->getDeclName();
11240  ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11241  ParameterName)
11242  << I + 1 << SecondParam->getDeclName();
11243  ParameterMismatch = true;
11244  break;
11245  };
11246 
11247  QualType FirstParamType = FirstParam->getType();
11248  QualType SecondParamType = SecondParam->getType();
11249  if (FirstParamType != SecondParamType &&
11250  ComputeQualTypeODRHash(FirstParamType) !=
11251  ComputeQualTypeODRHash(SecondParamType)) {
11252  if (const DecayedType *ParamDecayedType =
11253  FirstParamType->getAs<DecayedType>()) {
11254  ODRDiagError(FirstParam->getLocation(),
11255  FirstParam->getSourceRange(), ParameterType)
11256  << (I + 1) << FirstParamType << true
11257  << ParamDecayedType->getOriginalType();
11258  } else {
11259  ODRDiagError(FirstParam->getLocation(),
11260  FirstParam->getSourceRange(), ParameterType)
11261  << (I + 1) << FirstParamType << false;
11262  }
11263 
11264  if (const DecayedType *ParamDecayedType =
11265  SecondParamType->getAs<DecayedType>()) {
11266  ODRDiagNote(SecondParam->getLocation(),
11267  SecondParam->getSourceRange(), ParameterType)
11268  << (I + 1) << SecondParamType << true
11269  << ParamDecayedType->getOriginalType();
11270  } else {
11271  ODRDiagNote(SecondParam->getLocation(),
11272  SecondParam->getSourceRange(), ParameterType)
11273  << (I + 1) << SecondParamType << false;
11274  }
11275  ParameterMismatch = true;
11276  break;
11277  }
11278 
11279  const Expr *FirstInit = FirstParam->getInit();
11280  const Expr *SecondInit = SecondParam->getInit();
11281  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11282  ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11283  ParameterSingleDefaultArgument)
11284  << (I + 1) << (FirstInit == nullptr)
11285  << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11286  ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11287  ParameterSingleDefaultArgument)
11288  << (I + 1) << (SecondInit == nullptr)
11289  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11290  ParameterMismatch = true;
11291  break;
11292  }
11293 
11294  if (FirstInit && SecondInit &&
11295  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11296  ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11297  ParameterDifferentDefaultArgument)
11298  << (I + 1) << FirstInit->getSourceRange();
11299  ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11300  ParameterDifferentDefaultArgument)
11301  << (I + 1) << SecondInit->getSourceRange();
11302  ParameterMismatch = true;
11303  break;
11304  }
11305 
11306  assert(ComputeSubDeclODRHash(FirstParam) ==
11307  ComputeSubDeclODRHash(SecondParam) &&
11308  "Undiagnosed parameter difference.");
11309  }
11310 
11311  if (ParameterMismatch) {
11312  Diagnosed = true;
11313  break;
11314  }
11315 
11316  // If no error has been generated before now, assume the problem is in
11317  // the body and generate a message.
11318  ODRDiagError(FirstFunction->getLocation(),
11319  FirstFunction->getSourceRange(), FunctionBody);
11320  ODRDiagNote(SecondFunction->getLocation(),
11321  SecondFunction->getSourceRange(), FunctionBody);
11322  Diagnosed = true;
11323  break;
11324  }
11325  (void)Diagnosed;
11326  assert(Diagnosed && "Unable to emit ODR diagnostic.");
11327  }
11328 
11329  // Issue ODR failures diagnostics for enums.
11330  for (auto &Merge : EnumOdrMergeFailures) {
11331  enum ODREnumDifference {
11332  SingleScopedEnum,
11333  EnumTagKeywordMismatch,
11334  SingleSpecifiedType,
11335  DifferentSpecifiedTypes,
11336  DifferentNumberEnumConstants,
11337  EnumConstantName,
11338  EnumConstantSingleInitilizer,
11339  EnumConstantDifferentInitilizer,
11340  };
11341 
11342  // If we've already pointed out a specific problem with this enum, don't
11343  // bother issuing a general "something's different" diagnostic.
11344  if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11345  continue;
11346 
11347  EnumDecl *FirstEnum = Merge.first;
11348  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11349 
11350  using DeclHashes =
11352  auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11353  DeclHashes &Hashes, EnumDecl *Enum) {
11354  for (auto *D : Enum->decls()) {
11355  // Due to decl merging, the first EnumDecl is the parent of
11356  // Decls in both records.
11357  if (!ODRHash::isWhitelistedDecl(D, FirstEnum))
11358  continue;
11359  assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
11360  Hashes.emplace_back(cast<EnumConstantDecl>(D),
11361  ComputeSubDeclODRHash(D));
11362  }
11363  };
11364  DeclHashes FirstHashes;
11365  PopulateHashes(FirstHashes, FirstEnum);
11366  bool Diagnosed = false;
11367  for (auto &SecondEnum : Merge.second) {
11368 
11369  if (FirstEnum == SecondEnum)
11370  continue;
11371 
11372  std::string SecondModule =
11373  getOwningModuleNameForDiagnostic(SecondEnum);
11374 
11375  auto ODRDiagError = [FirstEnum, &FirstModule,
11376  this](SourceLocation Loc, SourceRange Range,
11377  ODREnumDifference DiffType) {
11378  return Diag(Loc, diag::err_module_odr_violation_enum)
11379  << FirstEnum << FirstModule.empty() << FirstModule << Range
11380  << DiffType;
11381  };
11382  auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11383  SourceRange Range,
11384  ODREnumDifference DiffType) {
11385  return Diag(Loc, diag::note_module_odr_violation_enum)
11386  << SecondModule << Range << DiffType;
11387  };
11388 
11389  if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11390  ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11391  SingleScopedEnum)
11392  << FirstEnum->isScoped();
11393  ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11394  SingleScopedEnum)
11395  << SecondEnum->isScoped();
11396  Diagnosed = true;
11397  continue;
11398  }
11399 
11400  if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11401  if (FirstEnum->isScopedUsingClassTag() !=
11402  SecondEnum->isScopedUsingClassTag()) {
11403  ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11404  EnumTagKeywordMismatch)
11405  << FirstEnum->isScopedUsingClassTag();
11406  ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11407  EnumTagKeywordMismatch)
11408  << SecondEnum->isScopedUsingClassTag();
11409  Diagnosed = true;
11410  continue;
11411  }
11412  }
11413 
11414  QualType FirstUnderlyingType =
11415  FirstEnum->getIntegerTypeSourceInfo()
11416  ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11417  : QualType();
11418  QualType SecondUnderlyingType =
11419  SecondEnum->getIntegerTypeSourceInfo()
11420  ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11421  : QualType();
11422  if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11423  ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11424  SingleSpecifiedType)
11425  << !FirstUnderlyingType.isNull();
11426  ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11427  SingleSpecifiedType)
11428  << !SecondUnderlyingType.isNull();
11429  Diagnosed = true;
11430  continue;
11431  }
11432 
11433  if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11434  if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11435  ComputeQualTypeODRHash(SecondUnderlyingType)) {
11436  ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11437  DifferentSpecifiedTypes)
11438  << FirstUnderlyingType;
11439  ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11440  DifferentSpecifiedTypes)
11441  << SecondUnderlyingType;
11442  Diagnosed = true;
11443  continue;
11444  }
11445  }
11446 
11447  DeclHashes SecondHashes;
11448  PopulateHashes(SecondHashes, SecondEnum);
11449 
11450  if (FirstHashes.size() != SecondHashes.size()) {
11451  ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11452  DifferentNumberEnumConstants)
11453  << (int)FirstHashes.size();
11454  ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11455  DifferentNumberEnumConstants)
11456  << (int)SecondHashes.size();
11457  Diagnosed = true;
11458  continue;
11459  }
11460 
11461  for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11462  if (FirstHashes[I].second == SecondHashes[I].second)
11463  continue;
11464  const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11465  const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11466 
11467  if (FirstEnumConstant->getDeclName() !=
11468  SecondEnumConstant->getDeclName()) {
11469 
11470  ODRDiagError(FirstEnumConstant->getLocation(),
11471  FirstEnumConstant->getSourceRange(), EnumConstantName)
11472  << I + 1 << FirstEnumConstant;
11473  ODRDiagNote(SecondEnumConstant->getLocation(),
11474  SecondEnumConstant->getSourceRange(), EnumConstantName)
11475  << I + 1 << SecondEnumConstant;
11476  Diagnosed = true;
11477  break;
11478  }
11479 
11480  const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11481  const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11482  if (!FirstInit && !SecondInit)
11483  continue;
11484 
11485  if (!FirstInit || !SecondInit) {
11486  ODRDiagError(FirstEnumConstant->getLocation(),
11487  FirstEnumConstant->getSourceRange(),
11488  EnumConstantSingleInitilizer)
11489  << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11490  ODRDiagNote(SecondEnumConstant->getLocation(),
11491  SecondEnumConstant->getSourceRange(),
11492  EnumConstantSingleInitilizer)
11493  << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11494  Diagnosed = true;
11495  break;
11496  }
11497 
11498  if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11499  ODRDiagError(FirstEnumConstant->getLocation(),
11500  FirstEnumConstant->getSourceRange(),
11501  EnumConstantDifferentInitilizer)
11502  << I + 1 << FirstEnumConstant;
11503  ODRDiagNote(SecondEnumConstant->getLocation(),
11504  SecondEnumConstant->getSourceRange(),
11505  EnumConstantDifferentInitilizer)
11506  << I + 1 << SecondEnumConstant;
11507  Diagnosed = true;
11508  break;
11509  }
11510  }
11511  }
11512 
11513  (void)Diagnosed;
11514  assert(Diagnosed && "Unable to emit ODR diagnostic.");
11515  }
11516 }
11517 
11519  if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11520  ReadTimer->startTimer();
11521 }
11522 
11524  assert(NumCurrentElementsDeserializing &&
11525  "FinishedDeserializing not paired with StartedDeserializing");
11526  if (NumCurrentElementsDeserializing == 1) {
11527  // We decrease NumCurrentElementsDeserializing only after pending actions
11528  // are finished, to avoid recursively re-calling finishPendingActions().
11529  finishPendingActions();
11530  }
11531  --NumCurrentElementsDeserializing;
11532 
11533  if (NumCurrentElementsDeserializing == 0) {
11534  // Propagate exception specification updates along redeclaration chains.
11535  while (!PendingExceptionSpecUpdates.empty()) {
11536  auto Updates = std::move(PendingExceptionSpecUpdates);
11537  PendingExceptionSpecUpdates.clear();
11538  for (auto Update : Updates) {
11539  ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11540  auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11541  auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11542  if (auto *Listener = getContext().getASTMutationListener())
11543  Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11544  for (auto *Redecl : Update.second->redecls())
11545  getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11546  }
11547  }
11548 
11549  if (ReadTimer)
11550  ReadTimer->stopTimer();
11551 
11552  diagnoseOdrViolations();
11553 
11554  // We are not in recursive loading, so it's safe to pass the "interesting"
11555  // decls to the consumer.
11556  if (Consumer)
11557  PassInterestingDeclsToConsumer();
11558  }
11559 }
11560 
11561 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11562  if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11563  // Remove any fake results before adding any real ones.
11564  auto It = PendingFakeLookupResults.find(II);
11565  if (It != PendingFakeLookupResults.end()) {
11566  for (auto *ND : It->second)
11567  SemaObj->IdResolver.RemoveDecl(ND);
11568  // FIXME: this works around module+PCH performance issue.
11569  // Rather than erase the result from the map, which is O(n), just clear
11570  // the vector of NamedDecls.
11571  It->second.clear();
11572  }
11573  }
11574 
11575  if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11576  SemaObj->TUScope->AddDecl(D);
11577  } else if (SemaObj->TUScope) {
11578  // Adding the decl to IdResolver may have failed because it was already in
11579  // (even though it was not added in scope). If it is already in, make sure
11580  // it gets in the scope as well.
11581  if (std::find(SemaObj->IdResolver.begin(Name),
11582  SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11583  SemaObj->TUScope->AddDecl(D);
11584  }
11585 }
11586 
11588  const PCHContainerReader &PCHContainerRdr,
11589  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11590  StringRef isysroot, bool DisableValidation,
11591  bool AllowASTWithCompilerErrors,
11592  bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11593  bool UseGlobalIndex,
11594  std::unique_ptr<llvm::Timer> ReadTimer)
11595  : Listener(DisableValidation
11597  : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11598  SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11599  PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11600  ContextObj(Context),
11601  ModuleMgr(PP.getFileManager(), PP.getPCMCache(), PCHContainerRdr,
11602  PP.getHeaderSearchInfo()),
11603  PCMCache(PP.getPCMCache()), DummyIdResolver(PP),
11604  ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11605  DisableValidation(DisableValidation),
11606  AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11607  AllowConfigurationMismatch(AllowConfigurationMismatch),
11608  ValidateSystemInputs(ValidateSystemInputs),
11609  UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11610  SourceMgr.setExternalSLocEntrySource(this);
11611 
11612  for (const auto &Ext : Extensions) {
11613  auto BlockName = Ext->getExtensionMetadata().BlockName;
11614  auto Known = ModuleFileExtensions.find(BlockName);
11615  if (Known != ModuleFileExtensions.end()) {
11616  Diags.Report(diag::warn_duplicate_module_file_extension)
11617  << BlockName;
11618  continue;
11619  }
11620 
11621  ModuleFileExtensions.insert({BlockName, Ext});
11622  }
11623 }
11624 
11626  if (OwnsDeserializationListener)
11627  delete DeserializationListener;
11628 }
11629 
11631  return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11632 }
11633 
11634 unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11635  unsigned AbbrevID) {
11636  Idx = 0;
11637  Record.clear();
11638  return Cursor.readRecord(AbbrevID, Record);
11639 }
llvm::APInt ReadAPInt(const RecordData &Record, unsigned &Idx)
Read an integral value.
Definition: ASTReader.cpp:9073
Decl * GetExistingDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration.
Definition: ASTReader.cpp:7329
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
unsigned IsAvailable
Whether this module is available in the current translation unit.
Definition: Module.h:213
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
CanQualType SatShortAccumTy
Definition: ASTContext.h:1022
void setSourceOrder(int Pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2432
CanQualType SatUnsignedLongFractTy
Definition: ASTContext.h:1026
Defines the clang::ASTContext interface.
The ObjC &#39;SEL&#39; type.
Definition: ASTBitCodes.h:889
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:4940
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:8121
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Finds all the visible declarations with a given name.
Definition: ASTReader.cpp:7541
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
Definition: ASTReader.h:380
Record code for the preprocessor options table.
Definition: ASTBitCodes.h:358
std::vector< unsigned > PreloadIdentifierOffsets
Offsets of identifiers that we&#39;re going to preload within IdentifierTableData.
Definition: Module.h:293
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
Definition: Module.h:309
The &#39;unsigned _Accum&#39; type.
Definition: ASTBitCodes.h:955
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
CanQualType LongLongTy
Definition: ASTContext.h:1013
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:1508
void setInfo(const DeclarationNameLoc &Info)
Represents a function declaration or definition.
Definition: Decl.h:1716
ASTReader(Preprocessor &PP, ASTContext *Context, const PCHContainerReader &PCHContainerRdr, ArrayRef< std::shared_ptr< ModuleFileExtension >> Extensions, StringRef isysroot="", bool DisableValidation=false, bool AllowASTWithCompilerErrors=false, bool AllowConfigurationMismatch=false, bool ValidateSystemInputs=false, bool UseGlobalIndex=true, std::unique_ptr< llvm::Timer > ReadTimer={})
Load the AST file and validate its contents against the given Preprocessor.
ASTFileSignature Signature
The module signature.
Definition: Module.h:106
std::string Name
The name of this module.
Definition: Module.h:68
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.
unsigned DirInfo
DirInfo - Keep track of whether this is a system header, and if so, whether it is C++ clean or not...
Definition: HeaderSearch.h:62
Source range/offset of a preprocessed entity.
Definition: ASTBitCodes.h:178
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:1684
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:7987
void * IdentifierLookupTable
A pointer to an on-disk hash table of opaque type IdentifierHashTable.
Definition: Module.h:289
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
Definition: ASTContext.h:1734
The &#39;unsigned short _Fract&#39; type.
Definition: ASTBitCodes.h:970
CanQualType AccumTy
Definition: ASTContext.h:1017
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
Definition: ASTReader.cpp:192
CanQualType OCLQueueTy
Definition: ASTContext.h:1042
Record code for potentially unused local typedef names.
Definition: ASTBitCodes.h:619
Record code for map of Objective-C class definition IDs to the ObjC categories in a module that are a...
Definition: ASTBitCodes.h:577
Smart pointer class that efficiently represents Objective-C method names.
static void updateModuleTimestamp(ModuleFile &MF)
Definition: ASTReader.cpp:3830
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
TypedefDecl * getCFConstantStringDecl() const
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
static hash_value_type ComputeHash(Selector Sel)
Definition: ASTReader.cpp:814
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:188
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:369
A (possibly-)qualified type.
Definition: Type.h:655
static LLVM_DUMP_METHOD void dumpModuleIDMap(StringRef Name, const ContinuousRangeMap< Key, ModuleFile *, InitialCapacity > &Map)
Definition: ASTReader.cpp:7723
virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines)
Receives the preprocessor options.
Definition: ASTReader.h:196
static void addMethodsToPool(Sema &S, ArrayRef< ObjCMethodDecl *> Methods, ObjCMethodList &List)
Add the given set of methods to the method list.
Definition: ASTReader.cpp:8077
void * getAsOpaquePtr() const
CtorInitializerType
The different kinds of data that can occur in a CtorInitializer.
Definition: ASTBitCodes.h:1987
The &#39;_Float16&#39; type.
Definition: ASTBitCodes.h:937
unsigned BasePreprocessedSkippedRangeID
Base ID for preprocessed skipped ranges local to this module.
Definition: Module.h:340
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:249
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1347
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:698
static bool startsWithASTFileMagic(BitstreamCursor &Stream)
Whether Stream starts with the AST/PCH file magic number &#39;CPCH&#39;.
Definition: ASTReader.cpp:4110
void SetIdentifierInfo(unsigned ID, IdentifierInfo *II)
Definition: ASTReader.cpp:8307
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:224
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:116
The &#39;unsigned int&#39; type.
Definition: ASTBitCodes.h:823
The (signed) &#39;long long&#39; type.
Definition: ASTBitCodes.h:850
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
CanQualType UnsignedLongFractTy
Definition: ASTContext.h:1021
virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)
This is called for each AST file loaded.
Definition: ASTReader.h:207
A simple structure that captures a vtable use for the purposes of the ExternalSemaSource.
SourceManager & getSourceManager() const
Definition: ASTReader.h:1485
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:404
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes...
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Definition: TemplateBase.h:366
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4398
Defines the clang::FileManager interface and associated types.
time_t getModificationTime() const
Definition: FileManager.h:91
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:7195
Record code for the source manager line table information, which stores information about #line direc...
Definition: ASTBitCodes.h:573
virtual StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const =0
Returns the serialized AST inside the PCH container Buffer.
CanQualType FractTy
Definition: ASTContext.h:1020
SourceRange getBraceRange() const
Definition: Decl.h:3147
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:131
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
The &#39;bool&#39; or &#39;_Bool&#39; type.
Definition: ASTBitCodes.h:811
std::string ModuleUserBuildPath
The directory used for a user build.
CanQualType Char32Ty
Definition: ASTContext.h:1012
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:2341
unsigned isPragmaOnce
True if this is a #pragma once file.
Definition: HeaderSearch.h:56
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1443
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
Definition: ASTBitCodes.h:1025
TypeLoc getNextTypeLoc() const
Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the TypeLoc is a PointerLoc and next Typ...
Definition: TypeLoc.h:169
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Definition: Type.h:1391
Stmt - This represents one statement.
Definition: Stmt.h:66
void setStarLoc(SourceLocation Loc)
Definition: TypeLoc.h:1278
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:5655
Expr * getBitWidth() const
Definition: Decl.h:2623
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1637
const FileEntry * getFile() const
Definition: Module.h:95
bool getEnableAllWarnings() const
Definition: Diagnostic.h:601
void AddQualType(QualType T)
Definition: ODRHash.cpp:828
void setExceptionSpecRange(SourceRange R)
Definition: TypeLoc.h:1457
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:142
SourceLocation DirectImportLoc
The source location where the module was explicitly or implicitly imported in the local translation u...
Definition: Module.h:202
unsigned IsExternC
Whether this is an &#39;extern "C"&#39; module (which implicitly puts all headers in it within an &#39;extern "C"...
Definition: Module.h:231
ControlRecordTypes
Record types that occur within the control block.
Definition: ASTBitCodes.h:301
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2741
void addTopHeaderFilename(StringRef Filename)
Add a top-level header filename associated with this module.
Definition: Module.h:502
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:179
unsigned Generation
The generation of which this module file is a part.
Definition: Module.h:175
void ReadComments() override
Loads comments ranges.
Definition: ASTReader.cpp:9160
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
Definition: Module.h:357
C Language Family Type Representation.
Defines the SourceManager interface.
The &#39;unknown any&#39; placeholder type.
Definition: ASTBitCodes.h:892
void setWrittenWidthSpec(TypeSpecifierWidth written)
Definition: TypeLoc.h:624
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
Source range of a skipped preprocessor region.
Definition: ASTBitCodes.h:202
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
Definition: ASTContext.h:1758
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
Definition: ASTReader.cpp:170
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
RawCommentList Comments
All comments in this translation unit.
Definition: ASTContext.h:713
DeclarationName getCXXConversionFunctionName(CanQualType Ty)
getCXXConversionFunctionName - Returns the name of a C++ conversion function for the given Type...
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTReader.cpp:8474
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, uint32_t Raw) const
Read a source location from raw form.
Definition: ASTReader.h:2176
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1918
QualType getEnumType(const EnumDecl *Decl) const
Defines the clang::Module class, which describes a module in the source code.
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
Definition: ASTBitCodes.h:157
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
SmallVector< uint64_t, 4 > PreloadSLocEntries
SLocEntries that we&#39;re going to preload.
Definition: Module.h:258
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
TagDecl * getDecl() const
Definition: Type.cpp:3148
CanQualType ObjCBuiltinSelTy
Definition: ASTContext.h:1036
RetTy Visit(TypeLoc TyLoc)
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:7497
Selector getObjCSelector() const
getObjCSelector - Get the Objective-C selector stored in this declaration name.
void VisitFunctionTypeLoc(FunctionTypeLoc)
Definition: ASTReader.cpp:6579
ModuleKind Kind
The type of this module.
Definition: Module.h:120
virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value)
Receives COUNTER value.
Definition: ASTReader.h:203
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
Defines the C++ template declaration subclasses.
Describes a source location entry (SLocEntry) for a macro expansion.
Definition: ASTBitCodes.h:676
std::vector< std::string > Includes
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
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:623
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl *> &Decls) override
Read the set of delegating constructors known to the external Sema source.
Definition: ASTReader.cpp:8183
An LValueReferenceType record.
Definition: ASTBitCodes.h:1047
The placeholder type for builtin functions.
Definition: ASTBitCodes.h:913
Defines the clang::MacroInfo and clang::MacroDirective classes.
const FileEntry * getASTFile() const
The serialized AST file for this module, if one was created.
Definition: Module.h:466
Defines types useful for describing an Objective-C runtime.
Specifies the submodules that are imported by this submodule.
Definition: ASTBitCodes.h:742
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorType::VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type...
std::string ModuleName
The name of the module.
Definition: Module.h:126
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl *> &TentativeDefs) override
Read the set of tentative definitions known to the external Sema source.
Definition: ASTReader.cpp:8162
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:1035
A record that stores the set of declarations that are lexically stored within a given DeclContext...
Definition: ASTBitCodes.h:1379
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
The module file is out-of-date.
Specifies an umbrella directory.
Definition: ASTBitCodes.h:738
The base class of the type hierarchy.
Definition: Type.h:1428
CanQualType SatUnsignedAccumTy
Definition: ASTContext.h:1023
bool isOutOfDate() const
Determine whether the information for this identifier is out of date with respect to the external sou...
IdentifierInfo * getLocalIdentifier(ModuleFile &M, unsigned LocalID)
Definition: ASTReader.cpp:8399
CanQualType LongTy
Definition: ASTContext.h:1013
DiagnosticsEngine & getDiagnostics() const
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
Definition: Module.h:439
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:1656
#define CHECK_TARGET_OPT(Field, Name)
A SubstTemplateTypeParmType record.
Definition: ASTBitCodes.h:1104
Decl * GetDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: ASTReader.cpp:7354
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2160
void setFlag(TokenFlags Flag)
Set the specified flag.
Definition: Token.h:234
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
Represent a C++ namespace.
Definition: Decl.h:514
Wrapper for source info for typedefs.
Definition: TypeLoc.h:665
static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II)
Definition: ASTReader.cpp:927
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:133
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:98
A container of type source information.
Definition: Decl.h:86
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:185
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:1925
Record code for enabled OpenCL extensions.
Definition: ASTBitCodes.h:556
Record code for the module build directory.
Definition: ASTBitCodes.h:334
Floating point control options.
Definition: LangOptions.h:263
bool isFromAST() const
Return true if the identifier in its current state was loaded from an AST file.
SourceLocation getLocStart() const LLVM_READONLY
Definition: Expr.h:1729
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:3732
An ElaboratedType record.
Definition: ASTBitCodes.h:1101
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
Definition: Module.h:384
An UnresolvedUsingType record.
Definition: ASTBitCodes.h:1107
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:625
Wrapper for source info for pointers decayed from arrays and functions.
Definition: TypeLoc.h:1232
The &#39;short _Fract&#39; type.
Definition: ASTBitCodes.h:961
ASTFileSignature Signature
The signature of the module file, which may be used instead of the size and modification time to iden...
Definition: Module.h:168
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
Definition: DeclBase.h:1913
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2477
An IncompleteArrayType record.
Definition: ASTBitCodes.h:1059
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
The internal &#39;__type_pack_element&#39; template.
Definition: ASTBitCodes.h:1266
diag::Severity getExtensionHandlingBehavior() const
Definition: Diagnostic.h:687
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:206
void addPendingMacro(IdentifierInfo *II, ModuleFile *M, uint64_t MacroDirectivesOffset)
Add a macro to deserialize its macro directive history.
Definition: ASTReader.cpp:1812
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:2036
Specifies a header that is part of the module but must be textually included.
Definition: ASTBitCodes.h:769
const uint32_t * SLocEntryOffsets
Offsets for all of the source location entries in the AST file.
Definition: Module.h:255
size_t param_size() const
Definition: Decl.h:2247
bool RelocatablePCH
Whether this precompiled header is a relocatable PCH file.
Definition: Module.h:155
CXXBaseSpecifier ReadCXXBaseSpecifier(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a C++ base specifier.
Definition: ASTReader.cpp:8864
ARC&#39;s unbridged-cast placeholder type.
Definition: ASTBitCodes.h:907
CanQualType HalfTy
Definition: ASTContext.h:1028
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:1504
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
The &#39;__int128_t&#39; type.
Definition: ASTBitCodes.h:871
The AST file has errors.
Definition: ASTReader.h:403
QualType withFastQualifiers(unsigned TQs) const
Definition: Type.h:870
The C++ &#39;char32_t&#39; type.
Definition: ASTBitCodes.h:880
An identifier, stored as an IdentifierInfo*.
The internal &#39;__builtin_va_list&#39; typedef.
Definition: ASTBitCodes.h:1245
The stack of open #ifs/#ifdefs recorded in a preamble.
Definition: ASTBitCodes.h:648
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:245
Manages the set of modules loaded by an AST reader.
Definition: ModuleManager.h:49
FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type.
Definition: DeclFriend.h:54
static Qualifiers fromOpaqueValue(unsigned opaque)
Definition: Type.h:260
Represents a variable declaration or definition.
Definition: Decl.h:814
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Record code for #pragma pack options.
Definition: ASTBitCodes.h:645
A block with unhashed content.
Definition: ASTBitCodes.h:297
QualType getReturnType() const
Definition: Decl.h:2271
std::string ImplicitPTHInclude
The implicit PTH input included at the start of the translation unit, or empty.
CXXCtorInitializer ** GetExternalCXXCtorInitializers(uint64_t Offset) override
Read the contents of a CXXCtorInitializer array.
Definition: ASTReader.cpp:7176
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1301
void VisitArrayTypeLoc(ArrayTypeLoc)
Definition: ASTReader.cpp:6524
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:272
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing)...
Definition: DiagnosticIDs.h:80
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6526
Record code for declarations associated with OpenCL extensions.
Definition: ASTBitCodes.h:640
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:7123
CanQualType Float128Ty
Definition: ASTContext.h:1016
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:57
Extra information about a function prototype.
Definition: Type.h:3551
CanQualType ShortAccumTy
Definition: ASTContext.h:1017
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1588
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
Definition: ASTReader.cpp:7775
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
Definition: Module.h:367
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
Definition: ASTBitCodes.h:1273
The value of the next COUNTER to dispense.
Definition: ASTBitCodes.h:481
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
unsigned getLineTableFilenameID(StringRef Str)
Specifies the umbrella header used to create this module, if any.
Definition: ASTBitCodes.h:729
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:601
A namespace, stored as a NamespaceDecl*.
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation >> &Sels) override
Definition: ASTReader.cpp:8216
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 ...
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
Record code for header search information.
Definition: ASTBitCodes.h:550
data_type ReadData(Selector, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:850
BlockCommandNamesTy BlockCommandNames
Command names to treat as block commands in comments.
void setAttrOperandParensRange(SourceRange range)
Definition: TypeLoc.h:1759
void setProtocolRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:783
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
void setBegin(SourceLocation b)
std::string ModuleCachePath
The directory used for the module cache.
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, TemplateName replacement) const
Describes a source location entry (SLocEntry) for a buffer.
Definition: ASTBitCodes.h:662
Used to hold and unique data used to represent #line information.
Record code for the target options table.
Definition: ASTBitCodes.h:349
CanQualType ShortFractTy
Definition: ASTContext.h:1020
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:120
void AddTemplateArgument(TemplateArgument TA)
Definition: ODRHash.cpp:140
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
Definition: ASTReader.cpp:800
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
Record code for the array of eagerly deserialized decls.
Definition: ASTBitCodes.h:452
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
Definition: Module.h:100
Represents a parameter to a function.
Definition: Decl.h:1535
Defines the clang::Expr interface and subclasses for C++ expressions.
unsigned isImport
True if this is a #import&#39;d or #pragma once file.
Definition: HeaderSearch.h:53
int SLocEntryBaseID
The base ID in the source manager&#39;s view of this module.
Definition: Module.h:248
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclTemplate.h:462
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
ContinuousRangeMap< uint32_t, int, 2 > DeclRemap
Remapping table for declaration IDs in this module.
Definition: Module.h:419
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2021
The collection of all-type qualifiers we support.
Definition: Type.h:154
void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo)
Definition: TypeLoc.h:1027
void clear()
Definition: ODRHash.cpp:181
SourceLocation ImportLoc
The source location where this module was first imported.
Definition: Module.h:205
An UnresolvedSet-like class that might not have been loaded from the external AST source yet...
bool needsExtraLocalData() const
Definition: TypeLoc.h:577
The width of the "fast" qualifier mask.
Definition: Type.h:197
ModuleKind Kind
The kind of this module.
Definition: Module.h:87
The client can handle an AST file that cannot load because it is missing.
Definition: ASTReader.h:1500
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:3118
CanQualType OCLSamplerTy
Definition: ASTContext.h:1041
bool DeclIsFromPCHWithObjectFile(const Decl *D) override
Determine whether D comes from a PCH which was built with a corresponding object file.
Definition: ASTReader.cpp:8492
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
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:8137
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
void setIsGNUVarargs()
Definition: MacroInfo.h:205
StringRef ModuleOffsetMap
The module offset map data for this file.
Definition: Module.h:216
Represents a struct/union/class.
Definition: Decl.h:3570
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
Definition: ASTBitCodes.h:45
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
RecordDecl * getCFConstantStringTagDecl() const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
Selector getUnarySelector(IdentifierInfo *ID)
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3458
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3552
One of these records is kept for each identifier that is lexed.
A macro directive exported by a module.
Definition: ASTBitCodes.h:702
TypeSourceInfo * getFriendType() const
If this friend declaration names an (untemplated but possibly dependent) type, return the type; other...
Definition: DeclFriend.h:124
void setLocalRangeEnd(SourceLocation L)
Definition: TypeLoc.h:1427
void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS)
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
Definition: ASTReader.cpp:179
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:735
std::string ActualOriginalSourceFileName
The actual original source file name that was used to build this AST file.
Definition: Module.h:142
The block containing comments.
Definition: ASTBitCodes.h:270
This table allows us to fully hide how we implement multi-keyword caching.
AddModuleResult
The result of attempting to add a new module.
bool isConst() const
Definition: DeclCXX.h:2087
The Objective-C &#39;SEL&#39; type.
Definition: ASTBitCodes.h:1227
StringLiteral * getMessage()
Definition: DeclCXX.h:3780
A library or framework to link against when an entity from this module is used.
Definition: Module.h:319
void finalizeForWriting()
Finalizes the AST reader&#39;s state before writing an AST file to disk.
Definition: ASTReader.cpp:4596
T * getFETokenInfo() const
getFETokenInfo/setFETokenInfo - The language front-end is allowed to associate arbitrary metadata wit...
Iteration over the preprocessed entities.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:330
static Module * getTopImportImplicitModule(ModuleManager &ModuleMgr, Preprocessor &PP)
Return the top import module if it is implicit, nullptr otherwise.
Definition: ASTReader.cpp:532
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:738
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
A C++ nested-name-specifier augmented with source location information.
Record the location of a macro definition.
LineState State
The &#39;char&#39; type, when it is signed.
Definition: ASTBitCodes.h:832
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:1333
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:72
void setBuiltinLoc(SourceLocation Loc)
Definition: TypeLoc.h:554
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1653
CanQualType UnsignedFractTy
Definition: ASTContext.h:1021
The &#39;unsigned long&#39; type.
Definition: ASTBitCodes.h:826
Specifies a header that has been explicitly excluded from this submodule.
Definition: ASTBitCodes.h:753
void setRBracketLoc(SourceLocation Loc)
Definition: TypeLoc.h:1546
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:198
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
SourceLocation getBegin() const
Definition: ASTBitCodes.h:192
Represents a member of a struct/union/class.
Definition: Decl.h:2534
bool isVolatile() const
Definition: DeclCXX.h:2088
bool isCPlusPlusOperatorKeyword() const
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
The &#39;_Sat unsigned _Accum&#39; type.
Definition: ASTBitCodes.h:991
Definition: Format.h:2031
ContinuousRangeMap< uint32_t, int, 2 > PreprocessedEntityRemap
Remapping table for preprocessed entity IDs in this module.
Definition: Module.h:334
Record code for the module map file that was used to build this AST file.
Definition: ASTBitCodes.h:331
One instance of this struct is kept for every file loaded or used.
Definition: SourceManager.h:95
std::vector< Entry > UserEntries
User specified include entries.
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:780
An ExtVectorType record.
Definition: ASTBitCodes.h:1068
Delete expressions that will be analyzed later.
Definition: ASTBitCodes.h:624
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.
CanQualType LongAccumTy
Definition: ASTContext.h:1017
method_range methods() const
Definition: DeclObjC.h:1057
Helper class that saves the current stream position and then restores it when destroyed.
Definition: ASTReader.h:2644
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:483
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
CanQualType OCLEventTy
Definition: ASTContext.h:1041
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3453
NamedDecl * getFriendDecl() const
If this friend declaration doesn&#39;t name a type, return the inner declaration.
Definition: DeclFriend.h:139
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2071
TemplateName ReadTemplateName(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a template name.
Definition: ASTReader.cpp:8708
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:405
The &#39;unsigned long _Fract&#39; type.
Definition: ASTBitCodes.h:976
The fast qualifier mask.
Definition: Type.h:200
virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the language options.
Definition: ASTReader.h:144
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:73
The &#39;long _Fract&#39; type.
Definition: ASTBitCodes.h:967
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.
void setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir, Twine NameAsWritten)
Sets the umbrella directory of the given module to the given directory.
Definition: ModuleMap.cpp:1072
void AddTemplateParameterList(const TemplateParameterList *TPL)
Definition: ODRHash.cpp:172
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
Wrapper for source info for unresolved typename using decls.
Definition: TypeLoc.h:687
std::string OriginalDir
The directory that the PCH was originally created in.
Definition: Module.h:150
void setKind(tok::TokenKind K)
Definition: Token.h:91
An AttributedType record.
Definition: ASTBitCodes.h:1137
uint32_t MacroID
An ID number that refers to a macro in an AST file.
Definition: ASTBitCodes.h:141
llvm::OnDiskChainedHashTable< HeaderFileInfoTrait > HeaderFileInfoLookupTable
The on-disk hash table used for known header files.
An object-like macro definition.
Definition: ASTBitCodes.h:686
void setUnderlyingTInfo(TypeSourceInfo *TInfo)
Definition: TypeLoc.h:1954
The client can handle an AST file that cannot load because it&#39;s compiled configuration doesn&#39;t match ...
Definition: ASTReader.h:1513
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1042
The signature of a module, which is a hash of the AST content.
Definition: Module.h:55
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:821
Describes one token.
Definition: ASTBitCodes.h:695
internal_key_type ReadKey(const unsigned char *d, unsigned)
Definition: ASTReader.cpp:828
An AdjustedType record.
Definition: ASTBitCodes.h:1155
Describes a module or submodule.
Definition: Module.h:65
TemplateDecl * getCXXDeductionGuideTemplate() const
If this name is the name of a C++ deduction guide, return the template associated with that name...
The &#39;short _Accum&#39; type.
Definition: ASTBitCodes.h:943
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:3872
void completeVisibleDeclsMap(const DeclContext *DC) override
Load all external visible decls in the given DeclContext.
Definition: ASTReader.cpp:7567
unsigned LocalNumHeaderFileInfos
The number of local HeaderFileInfo structures.
Definition: Module.h:348
Record code for the set of ext_vector type names.
Definition: ASTBitCodes.h:496
The &#39;long _Accum&#39; type.
Definition: ASTBitCodes.h:949
CanQualType LongFractTy
Definition: ASTContext.h:1020
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Definition: ASTReader.cpp:9109
llvm::Optional< ASTSourceDescriptor > getSourceDescriptor(unsigned ID) override
Return a descriptor for the corresponding module.
Definition: ASTReader.cpp:8528
unsigned External
Whether this header file info was supplied by an external source, and has not changed since...
Definition: HeaderSearch.h:66
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:581
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:461
bool isInvalid() const
const PPEntityOffset * PreprocessedEntityOffsets
Definition: Module.h:336
Specifies the submodules that are re-exported from this submodule.
Definition: ASTBitCodes.h:746
void setProtocolLoc(unsigned i, SourceLocation Loc)
Definition: TypeLoc.h:796
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
Definition: Decl.h:676
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:312
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2612
Selector getNullarySelector(IdentifierInfo *ID)
The Objective-C &#39;id&#39; type.
Definition: ASTBitCodes.h:1224
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:2297
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e...
Definition: Module.h:248
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:522
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:198
virtual void HandleInterestingDecl(DeclGroupRef D)
HandleInterestingDecl - Handle the specified interesting declaration.
Definition: ASTConsumer.cpp:23
PreprocessedEntity * ReadPreprocessedEntity(unsigned Index) override
Read a preallocated preprocessed entity from the external source.
Definition: ASTReader.cpp:5449
void setCaretLoc(SourceLocation Loc)
Definition: TypeLoc.h:1291
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2184
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:676
bool PCHHasObjectFile
Whether the PCH has a corresponding object file.
Definition: Module.h:161
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:6778
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:827
static void hash_combine(std::size_t &seed, const T &v)
tok::TokenKind getTokenID() const
If this is a source-language token (e.g.
unsigned getNumProtocols() const
Definition: TypeLoc.h:787
const unsigned NumSpecialTypeIDs
The number of special type IDs.
Definition: ASTBitCodes.h:1208
A convenient class for passing around template argument information.
Definition: TemplateBase.h:552
void setcudaConfigureCallDecl(FunctionDecl *FD)
Definition: ASTContext.h:1260
CanQualType SatShortFractTy
Definition: ASTContext.h:1025
uint32_t Offset
Definition: CacheTokens.cpp:43
Describes a blob that contains the data for a buffer entry.
Definition: ASTBitCodes.h:668
const FormatToken & Tok
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:346
The &#39;unsigned short _Accum&#39; type.
Definition: ASTBitCodes.h:952
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined &#39;SEL&#39; type in Objective-C.
void AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
Definition: ODRHash.cpp:496
void ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8694
CanQualType SatUnsignedShortAccumTy
Definition: ASTContext.h:1023
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
std::string Message
The message provided to the user when there is a conflict.
Definition: Module.h:365
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:7222
Wrapper for source info for functions.
Definition: TypeLoc.h:1396
Specifies a conflict with another module.
Definition: ASTBitCodes.h:762
The signed 128-bit integer type.
Definition: ASTBitCodes.h:1236
unsigned getHash() const
Compute a fingerprint of this key for use in on-disk hash table.
Definition: ASTReader.cpp:1052
CXXCtorInitializer ** ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a CXXCtorInitializer array.
Definition: ASTReader.cpp:8880
llvm::APSInt ReadAPSInt(const RecordData &Record, unsigned &Idx)
Read a signed integral value.
Definition: ASTReader.cpp:9082
A UnaryTransformType record.
Definition: ASTBitCodes.h:1146
bool isFileOverridden(const FileEntry *File) const
Returns true if the file contents have been overridden.
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:7421
An ObjCObjectType record.
Definition: ASTBitCodes.h:1113
A ConstantArrayType record.
Definition: ASTBitCodes.h:1056
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9102
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:745
llvm::iterator_range< ModuleDeclIterator > getModuleFileLevelDecls(ModuleFile &Mod)
Definition: ASTReader.cpp:5428
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:839
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:9243
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID)
Retrieve the global submodule ID given a module and its local ID number.
Definition: ASTReader.cpp:8459
Record code for #pragma optimize options.
Definition: ASTBitCodes.h:616
uint32_t BitOffset
Offset in the AST file.
Definition: ASTBitCodes.h:186
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9121
unsigned short NumIncludes
The number of times the file has been included already.
Definition: HeaderSearch.h:91
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1133
StringRef Data
The serialized bitstream data for this file.
Definition: Module.h:188
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:773
Record code for pending implicit instantiations.
Definition: ASTBitCodes.h:526
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:832
ExtKind hasExternalDefinitions(const Decl *D) override
Definition: ASTReader.cpp:8545
CanQualType PseudoObjectTy
Definition: ASTContext.h:1035
The internal &#39;__make_integer_seq&#39; template.
Definition: ASTBitCodes.h:1257
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1865
void setLazyBody(uint64_t Offset)
Definition: DeclObjC.h:531
TemplateArgument ReadTemplateArgument(ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument.
Definition: ASTReader.cpp:8767
const TemplateArgument & getArg(unsigned Idx) const
Definition: TemplateBase.h:694
bool isNull() const
Definition: TypeLoc.h:118
Record code for floating point #pragma options.
Definition: ASTBitCodes.h:553
CommentRecordTypes
Record types used within a comments block.
Definition: ASTBitCodes.h:785
Defines the Diagnostic-related interfaces.
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1383
static internal_key_type ReadKey(const unsigned char *d, unsigned n)
Definition: ASTReader.cpp:898
CanQualType LongDoubleTy
Definition: ASTContext.h:1016
void setMustBuildLookupTable()
Mark that there are external lexical declarations that we need to include in our lookup table (and th...
Definition: DeclBase.h:1888
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:403
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Module.h:216
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:138
Wrapper for source info for ObjC interfaces.
Definition: TypeLoc.h:1118
Record code for the set of known namespaces, which are used for typo correction.
Definition: ASTBitCodes.h:563
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5889
static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps)
Definition: ASTReader.cpp:2242
const serialization::reader::DeclContextLookupTable * getLoadedLookupTables(DeclContext *Primary) const
Get the loaded lookup tables for Primary, if any.
Definition: ASTReader.cpp:7591
bool hasRevertedBuiltin() const
True if setNotBuiltin() was called.
Record code for an array of all of the (sub)modules that were imported by the AST file...
Definition: ASTBitCodes.h:584
The &#39;unsigned short&#39; type.
Definition: ASTBitCodes.h:820
serialization::DeclID BaseDeclID
Base declaration ID for declarations local to this module.
Definition: Module.h:416
Present this diagnostic as an error.
const Expr * getInitExpr() const
Definition: Decl.h:2760
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
SourceLocation FirstLoc
The first source location in this module.
Definition: Module.h:208
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
A BlockPointerType record.
Definition: ASTBitCodes.h:1044
void setProtocolLoc(unsigned i, SourceLocation Loc)
Definition: TypeLoc.h:1057
A MemberPointerType record.
Definition: ASTBitCodes.h:1053
ContinuousRangeMap< uint32_t, int, 2 > SLocRemap
Remapping table for source locations in this module.
Definition: Module.h:261
The &#39;_Sat short _Fract&#39; type.
Definition: ASTBitCodes.h:997
unsigned DisableModuleHash
Whether we should disable the use of the hash string within the module cache.
The &#39;unsigned long _Accum&#39; type.
Definition: ASTBitCodes.h:958
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo >> &WI) override
Definition: ASTReader.cpp:8234
void setLocalRangeBegin(SourceLocation L)
Definition: TypeLoc.h:1419
void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag)
Definition: ASTReader.cpp:5714
Represents an ObjC class declaration.
Definition: DeclObjC.h:1193
This abstract interface provides operations for unwrapping containers for serialized ASTs (precompile...
void revertBuiltin()
Revert the identifier to a non-builtin identifier.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclCXX.h:3787
The AST file itself appears corrupted.
Definition: ASTReader.h:386
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
void dump()
Dump information about the AST reader to standard error.
Definition: ASTReader.cpp:7739
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3539
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &Exprs) override
Definition: ASTReader.cpp:8147
static ASTFileSignature readASTFileSignature(StringRef PCH)
Reads and return the signature record from PCH&#39;s control block, or else returns 0.
Definition: ASTReader.cpp:4602
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
The preprocessor keeps track of this information for each file that is #included. ...
Definition: HeaderSearch.h:51
A DependentSizedExtVectorType record.
Definition: ASTBitCodes.h:1167
The type of &#39;nullptr&#39;.
Definition: ASTBitCodes.h:874
uint64_t PreprocessorDetailStartOffset
The offset of the start of the preprocessor detail cursor.
Definition: Module.h:327
The &#39;_Sat unsigned long _Fract&#39; type.
Definition: ASTBitCodes.h:1012
CanQualType UnsignedCharTy
Definition: ASTContext.h:1014
Record code for the table of offsets into the block of source-location information.
Definition: ASTBitCodes.h:485
void setAttrNameLoc(SourceLocation loc)
Definition: TypeLoc.h:1738
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:1942
virtual bool needsInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
Definition: ASTReader.h:212
A SubstTemplateTypeParmPackType record.
Definition: ASTBitCodes.h:1140
static std::string ReadString(const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9095
TypeCode
Record codes for each kind of type.
Definition: ASTBitCodes.h:1033
Records the location of a macro expansion.
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:173
std::vector< std::string > ModuleFeatures
The names of any features to enable in module &#39;requires&#39; decls in addition to the hard-coded list in ...
Definition: LangOptions.h:189
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1545
Class that aids in the construction of nested-name-specifiers along with source-location information ...
void getExportedModules(SmallVectorImpl< Module *> &Exported) const
Appends this module&#39;s list of exported modules to Exported.
Definition: Module.cpp:293
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Module.h:226
The block containing information about the source manager.
Definition: ASTBitCodes.h:253
NodeId Parent
Definition: ASTDiff.cpp:192
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
The placeholder type for OpenMP array section.
Definition: ASTBitCodes.h:931
A VariableArrayType record.
Definition: ASTBitCodes.h:1062
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:2030
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:277
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
Definition: ASTBitCodes.h:242
StringRef getString() const
Definition: Expr.h:1633
void setUsedForHeaderGuard(bool Val)
Definition: MacroInfo.h:274
ASTRecordTypes
Record types that occur within the AST block itself.
Definition: ASTBitCodes.h:390
HashTableTy::const_iterator iterator
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1042
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:4387
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement into a statement.
Definition: ASTReader.cpp:7408
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
Definition: Decl.h:669
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3432
Defines the major attributes of a submodule, including its name and parent.
Definition: ASTBitCodes.h:725
llvm::BitstreamCursor Stream
The main bitstream cursor for the main block.
Definition: Module.h:191
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:183
The &#39;__uint128_t&#39; type.
Definition: ASTBitCodes.h:868
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:428
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
virtual bool needsImportVisitation() const
Returns true if this ASTReaderListener wants to receive the imports of the AST file via visitImport...
Definition: ASTReader.h:231
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
ModuleHeaderRole
Flags describing the role of a module header.
Definition: ModuleMap.h:122
ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, unsigned PriorGeneration)
Definition: ASTReader.cpp:8015
ModuleKind
Specifies the kind of module that has been loaded.
Definition: Module.h:43
StringRef Filename
Definition: Format.cpp:1605
A table of skipped ranges within the preprocessing record.
Definition: ASTBitCodes.h:651
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:202
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:548
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type...
bool isValid() const
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2674
bool isParameterPack() const
Whether this parameter is a non-type template parameter pack.
void ReadModuleMapFile(StringRef ModuleMapPath) override
Definition: ASTReader.cpp:155
void setSizeExpr(Expr *Size)
Definition: TypeLoc.h:1558
unsigned LocalNumSLocEntries
The number of source location entries in this AST file.
Definition: Module.h:245
QualType getAutoRRefDeductType() const
C++11 deduction pattern for &#39;auto &&&#39; type.
void setCFConstantStringType(QualType T)
Captures information about a #pragma weak directive.
Definition: Weak.h:25
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:2192
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:9215
ArrayRef< ObjCMethodDecl * > getInstanceMethods() const
Retrieve the instance methods found by this visitor.
Definition: ASTReader.cpp:8054
Record code for the table of offsets of each macro ID.
Definition: ASTBitCodes.h:601
const DirectoryEntry * Entry
Definition: Module.h:162
CanQualType UnsignedAccumTy
Definition: ASTContext.h:1019
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:452
void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo)
Definition: ASTReader.cpp:1959
void setAttrNameLoc(SourceLocation loc)
Definition: TypeLoc.h:900
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2168
static NestedNameSpecifier * SuperSpecifier(const ASTContext &Context, CXXRecordDecl *RD)
Returns the nested name specifier representing the __super scope for the given CXXRecordDecl.
CanQualType UnsignedShortFractTy
Definition: ASTContext.h:1021
A record containing CXXBaseSpecifiers.
Definition: ASTBitCodes.h:1493
void setAttrExprOperand(Expr *e)
Definition: TypeLoc.h:911
DiagnosticBuilder Diag(unsigned DiagID) const
Report a diagnostic.
Definition: ASTReader.cpp:9128
ASTReaderListener implementation to validate the information of the PCH file against an initialized P...
Definition: ASTReader.h:288
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:190
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:192
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
Specifies some declarations with initializers that must be emitted to initialize the module...
Definition: ASTBitCodes.h:777
An TemplateSpecializationType record.
Definition: ASTBitCodes.h:1119
An ObjCObjectPointerType record.
Definition: ASTBitCodes.h:1095
File is from a prebuilt module path.
Definition: Module.h:60
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:7039
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2305
Type source information for an attributed type.
Definition: TypeLoc.h:859
An ObjCInterfaceType record.
Definition: ASTBitCodes.h:1092
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.
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2140
HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE) override
Read the header file information for the given file entry.
Definition: ASTReader.cpp:5705
Describes a zlib-compressed blob that contains the data for a buffer entry.
Definition: ASTBitCodes.h:672
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
Expr - This represents one expression.
Definition: Expr.h:106
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
Definition: ASTReader.cpp:8510
Defines the clang::LangOptions interface.
SourceLocation getEnd() const
Definition: ASTBitCodes.h:196
SourceLocation End
Record code for the array of VTable uses.
Definition: ASTBitCodes.h:506
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
The &#39;char&#39; type, when it is unsigned.
Definition: ASTBitCodes.h:814
void setHasCommaPasting()
Definition: MacroInfo.h:219
static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
Definition: ASTReader.cpp:904
static InputFile getNotFound()
Definition: Module.h:89
void setModeAttr(bool written)
Definition: TypeLoc.h:647
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTReader.cpp:9151
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:8444
The directory that the PCH was originally created in.
Definition: ASTBitCodes.h:316
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3498
int Id
Definition: ASTDiff.cpp:191
The &#39;_Sat long _Fract&#39; type.
Definition: ASTBitCodes.h:1003
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
Declaration of a template type parameter.
bool wasUpgradedFromWarning() const
Whether this mapping attempted to map the diagnostic to a warning, but was overruled because the diag...
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:266
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
Definition: ASTReader.cpp:8254
The placeholder type for overloaded function sets.
Definition: ASTBitCodes.h:862
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
Definition: LangOptions.h:203
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:4866
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
virtual void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata)
Indicates that a particular module file extension has been read.
Definition: ASTReader.h:238
Inits[]
Definition: OpenMPClause.h:145
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
Definition: Module.h:255
QualType getTypeOfExprType(Expr *e) const
GCC extension.
Record code for the table of offsets to entries in the preprocessing record.
Definition: ASTBitCodes.h:503
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2700
ContinuousRangeMap< uint32_t, int, 2 > IdentifierRemap
Remapping table for identifier IDs in this module.
Definition: Module.h:279
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
QualType getParenType(QualType NamedType) const
CanQualType OMPArraySectionTy
Definition: ASTContext.h:1043
llvm::BitstreamCursor SLocEntryCursor
Cursor used to read source location entries.
Definition: Module.h:242
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
Defines version macros and version-related utility functions for Clang.
The OpenCL &#39;half&#39; / ARM NEON __fp16 type.
Definition: ASTBitCodes.h:904
const FileEntry * ContentsEntry
References the file which the contents were actually loaded from.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:554
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
Definition: DeclBase.h:729
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3405
Defines an enumeration for C++ overloaded operators.
Defines the clang::Preprocessor interface.
ArgKind
The kind of template argument we&#39;re storing.
Definition: TemplateBase.h:54
The block containing the detailed preprocessing record.
Definition: ASTBitCodes.h:264
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
Definition: ASTReader.h:317
Record code for #pragma diagnostic mappings.
Definition: ASTBitCodes.h:370
#define bool
Definition: stdbool.h:31
void setIsPoisoned(bool Value=true)
setIsPoisoned - Mark this identifier as poisoned.
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:1507
DeclContext * getDeclContext()
Definition: DeclBase.h:428
static LineEntry get(unsigned Offs, unsigned Line, int Filename, SrcMgr::CharacteristicKind FileKind, unsigned IncludeOffset)
void setWrittenSignSpec(TypeSpecifierSign written)
Definition: TypeLoc.h:608
llvm::BitstreamCursor InputFilesCursor
The cursor to the start of the input-files block.
Definition: Module.h:221
unsigned LocalNumMacros
The number of macros in this AST file.
Definition: Module.h:302
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a source range.
Definition: ASTReader.cpp:9065
A record containing CXXCtorInitializers.
Definition: ASTBitCodes.h:1496
CanQualType ShortTy
Definition: ASTContext.h:1013
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
Record code for the original file that was used to generate the AST file, including both its file ID ...
Definition: ASTBitCodes.h:313
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2301
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:2305
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
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:336
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
Definition: Sanitizers.h:67
QualType getLocalType(ModuleFile &F, unsigned LocalID)
Resolve a local type ID within a given AST file into a type.
Definition: ASTReader.cpp:7034
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:108
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
int Depth
Definition: ASTDiff.cpp:191
The &#39;long double&#39; type.
Definition: ASTBitCodes.h:859
Record code for the diagnostic options table.
Definition: ASTBitCodes.h:367
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
uint32_t IdentifierID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:61
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
Definition: ASTReader.cpp:209
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:1015
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:443
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1131
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1857
FileID OriginalSourceFileID
The file ID for the original source file that was used to build this AST file.
Definition: Module.h:146
A FunctionProtoType record.
Definition: ASTBitCodes.h:1074
void setInheritConstructors(bool Inherit=true)
Set that this base class&#39;s constructors should be inherited.
Definition: DeclCXX.h:260
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isInvalid() const
bool HasTimestamps
Whether timestamps are included in this module file.
Definition: Module.h:158
Describes a source location entry (SLocEntry) for a file.
Definition: ASTBitCodes.h:658
Wrapper for source info for enum types.
Definition: TypeLoc.h:725
A block containing a module file extension.
Definition: ASTBitCodes.h:291
bool isIdentifier() const
Predicate functions for querying what type of name this is.
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:165
std::string FileName
The file name of the module file.
Definition: Module.h:123
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 setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader, Twine NameAsWritten)
Sets the umbrella header of the given module to the given header.
Definition: ModuleMap.cpp:1060
void setEllipsisLoc(SourceLocation Loc)
Definition: TypeLoc.h:2249
Record code for an update to a decl context&#39;s lookup table.
Definition: ASTBitCodes.h:533
ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored aft...
Definition: TypeLoc.h:747
void setHasBaseTypeAsWritten(bool HasBaseType)
Definition: TypeLoc.h:1076
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:439
Record code for #pragma ms_struct options.
Definition: ASTBitCodes.h:627
InclusionKind
The kind of inclusion directives known to the preprocessor.
QualType getRecordType(const RecordDecl *Decl) const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
SourceLocation getEnd() const
unsigned ModulesValidateOncePerBuildSession
If true, skip verifying input files used by modules if the module was already verified during this bu...
bool isInstanceMethod() const
Definition: DeclObjC.h:454
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:1365
struct CXXOpName CXXOperatorName
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation >> &Pending) override
Definition: ASTReader.cpp:8266
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
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.
CanQualType SatLongAccumTy
Definition: ASTContext.h:1022
void insertOrReplace(const value_type &Val)
void addMethodToGlobalList(ObjCMethodList *List, ObjCMethodDecl *Method)
Add the given method to the list of globally-known methods.
bool isAvailable() const
Determine whether this module is available for use within the current translation unit...
Definition: Module.h:379
void StartedDeserializing() override
Notify ASTReader that we started deserialization of a decl or type so until FinishedDeserializing is ...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3747
Selector getSelector() const
Definition: DeclObjC.h:361
Information about a header directive as found in the module map file.
Definition: Module.h:151
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:1381
The result type of a method or function.
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1945
unsigned SLocEntryBaseOffset
The base offset in the source manager&#39;s view of this module.
Definition: Module.h:251
Record code for the table of offsets of each identifier ID.
Definition: ASTBitCodes.h:423
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2080
MemoryBufferSizes getMemoryBufferSizes() const
Return the amount of memory used by memory buffers, breaking down by heap-backed versus mmap&#39;ed memor...
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
Record code for undefined but used functions and variables that need a definition in this TU...
Definition: ASTBitCodes.h:610
void ReadDeclarationNameInfo(ModuleFile &F, DeclarationNameInfo &NameInfo, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8684
A DependentNameType record.
Definition: ASTBitCodes.h:1122
const SourceManager & SM
Definition: Format.cpp:1475
unsigned MajorVersion
The major version of the extension data.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:236
CanQualType SignedCharTy
Definition: ASTContext.h:1013
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
Record code for the identifier table.
Definition: ASTBitCodes.h:442
The &#39;_Sat unsigned long _Accum&#39; type.
Definition: ASTBitCodes.h:994
The AST file was missing.
Definition: ASTReader.h:389
uint64_t BuildSessionTimestamp
The time in seconds when the build session started.
unsigned MinorVersion
The minor version of the extension data.
bool hasAttrExprOperand() const
Definition: TypeLoc.h:868
NestedNameSpecifier * ReadNestedNameSpecifier(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8946
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:895
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
void setIsUsed(bool Val)
Set the value of the IsUsed flag.
Definition: MacroInfo.h:153
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:3781
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
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:1309
std::vector< std::unique_ptr< ModuleFileExtensionReader > > ExtensionReaders
The list of extension readers that are attached to this module file.
Definition: Module.h:212
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
Definition: ASTBitCodes.h:138
void setTypeofLoc(SourceLocation Loc)
Definition: TypeLoc.h:1849
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
Definition: Sanitizers.h:85
The Objective-C &#39;Class&#39; type.
Definition: ASTBitCodes.h:1230
SpecifierKind
The kind of specifier that completes this nested name specifier.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:409
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:788
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:172
void makeNamesVisible(const HiddenNames &Names, Module *Owner)
Make the names within this set of hidden names visible.
Definition: ASTReader.cpp:3718
The &#39;_Sat short _Accum&#39; type.
Definition: ASTBitCodes.h:979
StringRef Next() override
Retrieve the next string in the identifier table and advances the iterator for the following string...
Definition: ASTReader.cpp:7934
The &#39;unsigned long long&#39; type.
Definition: ASTBitCodes.h:829
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:211
Wrapper for source info for arrays.
Definition: TypeLoc.h:1529
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
Record code for the set of source location entries that need to be preloaded by the AST reader...
Definition: ASTBitCodes.h:493
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Definition: Decl.h:662
CanQualType OverloadTy
Definition: ASTContext.h:1033
The control block was read successfully.
Definition: ASTReader.h:383
The list of delegating constructor declarations.
Definition: ASTBitCodes.h:559
Information about a FileID, basically just the logical file that it represents and include stack info...
Compare comments&#39; source locations.
The C++ &#39;char8_t&#39; type.
Definition: ASTBitCodes.h:940
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
Record code for types associated with OpenCL extensions.
Definition: ASTBitCodes.h:637
void setAttrOperandParensRange(SourceRange range)
Definition: TypeLoc.h:936
static bool readBit(unsigned &Bits)
Definition: ASTReader.cpp:914
void setIsFunctionLike()
Function/Object-likeness.
Definition: MacroInfo.h:199
unsigned isModuleHeader
Whether this header is part of a module.
Definition: HeaderSearch.h:69
const unsigned char * SelectorLookupTableData
A pointer to the character data that comprises the selector table.
Definition: Module.h:392
Encapsulates changes to the "macros namespace" (the location where the macro name became active...
Definition: MacroInfo.h:291
bool ReadFullVersionInformation(StringRef FullVersion) override
Receives the full Clang version information.
Definition: ASTReader.cpp:145
#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:456
CanQualType BuiltinFnTy
Definition: ASTContext.h:1034
ContinuousRangeMap< uint32_t, int, 2 > SelectorRemap
Remapping table for selector IDs in this module.
Definition: Module.h:387
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply...
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:471
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3529
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
Definition: ASTReader.cpp:8302
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2176
serialization::IdentID BaseIdentifierID
Base identifier ID for identifiers local to this module.
Definition: Module.h:276
MacroInfo * ReadMacroRecord(ModuleFile &F, uint64_t Offset)
Reads the macro record located at the given offset.
Definition: ASTReader.cpp:1574
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:8126
File is a PCH file treated as the preamble.
Definition: Module.h:54
std::string getTimestampFilename() const
Definition: Module.h:131
static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method)
Move the given method to the back of the global list of methods.
Definition: ASTReader.cpp:3690
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3558
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into &#39;__super&#39; nested-name-specifier.
The &#39;_Sat unsigned _Fract&#39; type.
Definition: ASTBitCodes.h:1009
bool isParameterPack() const
Returns whether this is a parameter pack.
Encodes a location in the source.
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2041
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:774
StringRef getName() const
Definition: FileManager.h:84
CanQualType UnsignedLongAccumTy
Definition: ASTContext.h:1019
A record that stores the set of declarations that are visible from a given DeclContext.
Definition: ASTBitCodes.h:1388
File is a PCH file treated as such.
Definition: Module.h:51
CanQualType Int128Ty
Definition: ASTContext.h:1013
IdentifierInfo * get(StringRef Name) override
Retrieve the IdentifierInfo for the named identifier.
Definition: ASTReader.cpp:7862
void setLength(unsigned Len)
Definition: Token.h:133
Specifies a library or framework to link against.
Definition: ASTBitCodes.h:756
Record code for file ID of the file or buffer that was used to generate the AST file.
Definition: ASTBitCodes.h:320
Represents a C++ temporary.
Definition: ExprCXX.h:1213
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5555
void InitializeContext()
Initializes the ASTContext.
Definition: ASTReader.cpp:4457
Specifies a header that falls into this (sub)module.
Definition: ASTBitCodes.h:732
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
std::string ExportAsModule
The module through which entities defined in this module will eventually be exposed, for use in "private" modules.
Definition: Module.h:113
ContinuousRangeMap< uint32_t, int, 2 > SubmoduleRemap
Remapping table for submodule IDs in this module.
Definition: Module.h:370
void setUsed(bool Used=true)
Definition: Weak.h:36
typename Representation::const_iterator const_iterator
Record code for special CUDA declarations.
Definition: ASTBitCodes.h:547
Options for controlling the compiler diagnostics engine.
A list of "interesting" identifiers.
Definition: ASTBitCodes.h:606
NameVisibilityKind NameVisibility
The visibility of names within this particular module.
Definition: Module.h:275
An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files...
Definition: ASTReader.cpp:7901
void setProtocolLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:773
The block of configuration options, used to check that a module is being used in a configuration comp...
Definition: ASTBitCodes.h:288
CanQualType SatFractTy
Definition: ASTContext.h:1025
DeclarationName getName() const
getName - Returns the embedded declaration name.
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3020
PredefinedTypeIDs
Predefined type IDs.
Definition: ASTBitCodes.h:803
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.h:401
All of the names in this module are hidden.
Definition: Module.h:269
File is an implicitly-loaded module.
Definition: Module.h:45
void setProtocolRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1044
The &#39;unsigned char&#39; type.
Definition: ASTBitCodes.h:817
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2676
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
Definition: Module.h:477
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class...
Metadata describing this particular extension.
Definition: ASTBitCodes.h:376
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:201
void setIsC99Varargs()
Varargs querying methods. This can only be set for function-like macros.
Definition: MacroInfo.h:204
MacroInfo * getMacro(serialization::MacroID ID)
Retrieve the macro with the given ID.
Definition: ASTReader.cpp:8418
uint64_t SizeInBits
The size of this file, in bits.
Definition: Module.h:182
TemplateParameterList * ReadTemplateParameterList(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a template parameter list.
Definition: ASTReader.cpp:8822
An ObjCTypeParamType record.
Definition: ASTBitCodes.h:1161
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
The (signed) &#39;long&#39; type.
Definition: ASTBitCodes.h:847
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2045
ModuleReverseIterator rbegin()
Reverse iterator to traverse all loaded modules.
Record code for the offsets of each decl.
Definition: ASTBitCodes.h:415
SourceLocation getFriendLoc() const
Retrieves the location of the &#39;friend&#39; keyword.
Definition: DeclFriend.h:144
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:8084
void * SelectorLookupTable
A pointer to an on-disk hash table of opaque type ASTSelectorLookupTable.
Definition: Module.h:399
Metadata for submodules as a whole.
Definition: ASTBitCodes.h:721
SourceLocation getFileLoc(SourceLocation Loc) const
Given Loc, if it is a macro location return the expansion location or the spelling location...
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
const uint32_t * IdentifierOffsets
Offsets into the identifier table data.
Definition: Module.h:273
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Class that performs lookup for a selector&#39;s entries in the global method pool stored in an AST file...
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:613
CanQualType FloatTy
Definition: ASTContext.h:1016
const FileEntry * Entry
Definition: Module.h:153
A dependentSizedVectorType record.
Definition: ASTBitCodes.h:1173
The (signed) &#39;short&#39; type.
Definition: ASTBitCodes.h:841
Defines the clang::TargetOptions class.
void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc)
Turn this (empty) nested-name-specifier into the global nested-name-specifier &#39;::&#39;.
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2254
void setDefinitionEndLoc(SourceLocation EndLoc)
Set the location of the last token in the macro.
Definition: MacroInfo.h:127
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3774
bool isPoisoned() const
Return true if this token has been poisoned.
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:134
CanQualType SatUnsignedLongAccumTy
Definition: ASTContext.h:1023
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings startin...
Definition: TargetOptions.h:55
The &#39;_Sat _Accum&#39; type.
Definition: ASTBitCodes.h:982
unsigned LocalNumDecls
The number of declarations in this AST file.
Definition: Module.h:409
void setUpgradedFromWarning(bool Value)
SourceRange ReadSkippedRange(unsigned Index) override
Read a preallocated skipped range from the external source.
Definition: ASTReader.cpp:5435
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:1903
The internal &#39;instancetype&#39; typedef.
Definition: ASTBitCodes.h:1242
CanQualType VoidTy
Definition: ASTContext.h:1004
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3493
OptionsRecordTypes
Record types that occur within the options block inside the control block.
Definition: ASTBitCodes.h:339
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
CanQualType Float16Ty
Definition: ASTContext.h:1029
Describes the categories of an Objective-C class.
Definition: ASTBitCodes.h:2024
QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl, ArrayRef< ObjCProtocolDecl *> protocols, QualType Canonical=QualType()) const
bool isDeclIDFromModule(serialization::GlobalDeclID ID, ModuleFile &M) const
Returns true if global DeclID ID originated from module M.
Definition: ASTReader.cpp:7236
CanQualType SatLongFractTy
Definition: ASTContext.h:1025
The AST block, which acts as a container around the full AST block.
Definition: ASTBitCodes.h:249
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition: Type.h:1379
ArrayRef< ObjCMethodDecl * > getFactoryMethods() const
Retrieve the instance methods found by this visitor.
Definition: ASTReader.cpp:8059
IdentID ReadIdentifierID(const unsigned char *d)
Definition: ASTReader.cpp:920
A DeducedTemplateSpecializationType record.
Definition: ASTBitCodes.h:1164
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2128
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:702
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:86
void setWrittenTypeSpec(TypeSpecifierType written)
Definition: TypeLoc.h:635
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
unsigned getODRHash()
Returns ODRHash of the function.
Definition: Decl.cpp:3671
void setAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1369
UnhashedControlBlockRecordTypes
Record codes for the unhashed control block.
Definition: ASTBitCodes.h:362
llvm::SetVector< ModuleFile * > ImportedBy
List of modules which depend on this module.
Definition: Module.h:467
void setLBracketLoc(SourceLocation Loc)
Definition: TypeLoc.h:1538
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
void dump()
Dump debugging output for this module.
Definition: Module.cpp:48
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:267
Updates[]
Definition: OpenMPClause.h:145
An InjectedClassNameType record.
Definition: ASTBitCodes.h:1110
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:8332
const serialization::DeclID * FileSortedDecls
Array of file-level DeclIDs sorted by file.
Definition: Module.h:431
Record code for the extra statistics we gather while generating an AST file.
Definition: ASTBitCodes.h:465
static Decl * getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID)
Definition: ASTReader.cpp:7273
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1938
virtual void visitImport(StringRef Filename)
If needsImportVisitation returns true, this is called for each AST file imported by this AST file...
Definition: ASTReader.h:235
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2065
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3754
static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool Complain)
Definition: ASTReader.cpp:456
std::vector< InputFile > InputFilesLoaded
The input files that have been loaded from this AST file.
Definition: Module.h:227
CanQualType SatUnsignedFractTy
Definition: ASTContext.h:1026
std::string PCHThroughHeader
If non-empty, the filename used in an #include directive in the primary source file (or command-line ...
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
Definition: ASTBitCodes.h:169
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:8607
The &#39;signed char&#39; type.
Definition: ASTBitCodes.h:835
unsigned LocalNumSubmodules
The number of submodules in this module.
Definition: Module.h:364
unsigned ComputeHash(Selector Sel)
Definition: ASTCommon.cpp:242
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:400
CanQualType SatUnsignedShortFractTy
Definition: ASTContext.h:1026
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:8591
const char * HeaderFileInfoTableData
Actual data for the on-disk hash table of header file information.
Definition: Module.h:355
void markIdentifierUpToDate(IdentifierInfo *II)
Note that this identifier is up-to-date.
Definition: ASTReader.cpp:1948
const llvm::support::unaligned_uint64_t * InputFileOffsets
Offsets for all of the input file entries in the AST file.
Definition: Module.h:224
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:592
Record code for the signature that identifiers this AST file.
Definition: ASTBitCodes.h:364
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Definition: ModuleMap.cpp:1140
File is a PCH file treated as the actual main file.
Definition: Module.h:57
llvm::APFloat ReadAPFloat(const RecordData &Record, const llvm::fltSemantics &Sem, unsigned &Idx)
Read a floating-point value.
Definition: ASTReader.cpp:9088
Record code for referenced selector pool.
Definition: ASTBitCodes.h:511
The input file that has been loaded from this AST file, along with bools indicating whether this was ...
Definition: Module.h:66
void AddSubDecl(const Decl *D)
Definition: ODRHash.cpp:443
std::vector< std::string > MacroIncludes
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2478
CanQualType SatAccumTy
Definition: ASTContext.h:1022
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4794
ModuleFile * getLocalModuleFile(ModuleFile &M, unsigned ID)
Retrieve the module file with a given local ID within the specified ModuleFile.
Definition: ASTReader.cpp:8497
Record code for the set of non-builtin, special types.
Definition: ASTBitCodes.h:461
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:1435
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:658
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1629
SourceLocation getBegin() const
Definition: ASTBitCodes.h:212
StringRef getName() const
Return the actual identifier string.
void setTypeArgsLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1006
uint64_t InputFilesValidationTimestamp
If non-zero, specifies the time when we last validated input files.
Definition: Module.h:237
CanQualType UnsignedShortTy
Definition: ASTContext.h:1014
llvm::MemoryBuffer * getRawBuffer() const
Get the underlying buffer, returning NULL if the buffer is not yet available.
const uint32_t * MacroOffsets
Offsets of macros in the preprocessor block.
Definition: Module.h:309
The ObjC &#39;id&#39; type.
Definition: ASTBitCodes.h:883
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Canon=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2872
unsigned LocalNumSelectors
The number of selectors new to this file.
Definition: Module.h:377
unsigned getObjCOrBuiltinID() const
const PPSkippedRange * PreprocessedSkippedRangeOffsets
Definition: Module.h:342
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
CanQualType CharTy
Definition: ASTContext.h:1006
unsigned ControllingMacroID
The ID number of the controlling macro.
Definition: HeaderSearch.h:98
Represents a template argument.
Definition: TemplateBase.h:51
Record code for the list of other AST files imported by this AST file.
Definition: ASTBitCodes.h:308
Selector getLocalSelector(ModuleFile &M, unsigned LocalID)
Retrieve a selector from the given module with its local ID number.
Definition: ASTReader.cpp:8552
Describes a macro definition within the preprocessing record.
Definition: ASTBitCodes.h:711
const ASTTemplateArgumentListInfo * ReadASTTemplateArgumentListInfo(ModuleFile &F, const RecordData &Record, unsigned &Index)
Definition: ASTReader.cpp:7107
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
A conflict between two modules.
Definition: Module.h:360
void setClassTInfo(TypeSourceInfo *TI)
Definition: TypeLoc.h:1321
bool ReadSLocEntry(int ID) override
Read the source location entry with index ID.
Definition: ASTReader.cpp:1363
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
Definition: ASTReader.cpp:791
The internal &#39;__NSConstantString&#39; typedef.
Definition: ASTBitCodes.h:1260
Record code for the module name.
Definition: ASTBitCodes.h:327
QualType getTypeOfType(QualType t) const
getTypeOfType - Unlike many "get<Type>" functions, we don&#39;t unique TypeOfType nodes.
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
Definition: ASTBitCodes.h:154
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:948
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1036
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
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:2227
Dataflow Directional Tag Classes.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:833
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, const TemplateArgument &ArgPack) const
bool isValid() const
Return true if this is a valid SourceLocation object.
void setDeserializationListener(ASTDeserializationListener *Listener, bool TakeOwnership=false)
Set the AST deserialization listener.
Definition: ASTReader.cpp:808
Describes an inclusion directive within the preprocessing record.
Definition: ASTBitCodes.h:715
The internal &#39;__builtin_ms_va_list&#39; typedef.
Definition: ASTBitCodes.h:1251
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block.
Definition: Module.h:406
unsigned IsMissingRequirement
Whether this module is missing a feature from Requirements.
Definition: Module.h:204
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:499
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:1264
Record code for a file sorted array of DeclIDs in a module.
Definition: ASTBitCodes.h:580
void setAmpAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1383
CanQualType NullPtrTy
Definition: ASTContext.h:1032
Record code for the array of Objective-C categories (including extensions).
Definition: ASTBitCodes.h:594
void updateOutOfDateIdentifier(IdentifierInfo &II) override
Update an out-of-date identifier.
Definition: ASTReader.cpp:1923
void reserve(ASTContext &C, unsigned N)
Specifies a configuration macro for this module.
Definition: ASTBitCodes.h:759
void ReadDefinedMacros() override
Read the set of macros defined by this external macro source.
Definition: ASTReader.cpp:1819
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
PreprocessorDetailRecordTypes
Record types used within a preprocessor detail block.
Definition: ASTBitCodes.h:706
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:4118
bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain) override
Receives the file system options.
Definition: ASTReader.cpp:186
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:28
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
uint64_t MacroStartOffset
The offset of the start of the set of defined macros.
Definition: Module.h:318
CanQualType UnsignedShortAccumTy
Definition: ASTContext.h:1019
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:80
SourceLocation TranslateSourceLocation(ModuleFile &ModuleFile, SourceLocation Loc) const
Translate a source location from another module file&#39;s source location space into ours...
Definition: ASTReader.h:2183
Record code for the array of unused file scoped decls.
Definition: ASTBitCodes.h:499
A FunctionNoProtoType record.
Definition: ASTBitCodes.h:1071
off_t getSize() const
Definition: FileManager.h:87
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:199
The &#39;_Sat unsigned short _Accum&#39; type.
Definition: ASTBitCodes.h:988
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:3845
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
File is an explicitly-loaded module.
Definition: Module.h:48
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2780
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
Definition: ASTReader.cpp:430
QualType getUnderlyingType() const
Definition: Decl.h:2927
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1015
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:231
const Expr * getInit() const
Definition: Decl.h:1219
AccessSpecifier getAccess() const
Definition: DeclBase.h:463
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.
The &#39;_Sat long _Accum&#39; type.
Definition: ASTBitCodes.h:985
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl *> &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
Definition: ASTReader.cpp:8194
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:578
Record code for the Objective-C method pool,.
Definition: ASTBitCodes.h:477
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
Definition: Module.h:288
bool isExtensionToken() const
get/setExtension - Initialize information about whether or not this language token is an extension...
virtual void ReadModuleMapFile(StringRef ModuleMapPath)
Definition: ASTReader.h:139
Kind getKind() const
Definition: DeclBase.h:422
Specifies a header that is private to this submodule.
Definition: ASTBitCodes.h:765
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like &#39;int()&#39;.
bool needsInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
Definition: ASTReader.cpp:215
U cast(CodeGen::Address addr)
Definition: Address.h:109
Describes a macro expansion within the preprocessing record.
Definition: ASTBitCodes.h:708
llvm::OnDiskChainedHashTable< ASTSelectorLookupTrait > ASTSelectorLookupTable
The on-disk hash table used for the global method pool.
Represents an enum.
Definition: Decl.h:3313
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:3825
IdentifierTable & getIdentifierTable()
Retrieve the identifier table associated with the preprocessor.
Definition: ASTReader.cpp:9138
Expr * getDefaultArgument() const
Retrieve the default argument, if any.
IdentifierResolver IdResolver
Definition: Sema.h:801
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.
bool defaultArgumentWasInherited() const
Determines whether the default argument was inherited from a previous declaration of this template...
void setExternalSLocEntrySource(ExternalSLocEntrySource *Source)
ContinuousRangeMap< uint32_t, int, 2 > MacroRemap
Remapping table for macro IDs in this module.
Definition: Module.h:315
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
An RValueReferenceType record.
Definition: ASTBitCodes.h:1050
void ReadDeclarationNameLoc(ModuleFile &F, DeclarationNameLoc &DNLoc, DeclarationName Name, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8651
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
void ClearSwitchCaseIDs()
Definition: ASTReader.cpp:9156
std::string BlockName
The name used to identify this particular extension block within the resulting module file...
bool isHidden() const
Determine whether this declaration might be hidden from name lookup.
Definition: DeclBase.h:774
void setHasExternalLexicalStorage(bool ES=true)
State whether this DeclContext has external storage for declarations lexically in this context...
Definition: DeclBase.h:1907
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:69
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:8278
An AtomicType record.
Definition: ASTBitCodes.h:1149
const Expr * Replacement
Definition: ParsedAttr.h:67
static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, ASTConsumer *Consumer)
Under non-PCH compilation the consumer receives the objc methods before receiving the implementation...
Definition: ASTReader.cpp:7600
The placeholder type for dependent types.
Definition: ASTBitCodes.h:865
All of the names in this module are visible.
Definition: Module.h:271
unsigned getNumParams() const
Definition: TypeLoc.h:1471
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2091
bool hasAttrEnumOperand() const
Definition: TypeLoc.h:873
Number of unmatched #pragma clang cuda_force_host_device begin directives we&#39;ve seen.
Definition: ASTBitCodes.h:634
unsigned ModuleMapIsPrivate
Whether this module came from a "private" module map, found next to a regular (public) module map...
Definition: Module.h:263
uint64_t SanitizerMask
Definition: Sanitizers.h:26
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
Decl * GetExternalDecl(uint32_t ID) override
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: ASTReader.cpp:7119
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:889
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...
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition: Type.h:3543
void ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set, const RecordData &Record, unsigned &Idx)
Read a UnresolvedSet structure.
Definition: ASTReader.cpp:8852
void setAttrEnumOperandLoc(SourceLocation loc)
Definition: TypeLoc.h:923
struct CXXLitOpName CXXLiteralOperatorName
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:126
void addLinkAsDependency(Module *Mod)
Make module to use export_as as the link dependency name if enough information is available or add it...
Definition: ModuleMap.cpp:68
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4135
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
BuiltinTemplateDecl * getTypePackElementDecl() const
CanQualType UnknownAnyTy
Definition: ASTContext.h:1033
The &#39;unsigned _Fract&#39; type.
Definition: ASTBitCodes.h:973
std::vector< Conflict > Conflicts
The list of conflicts.
Definition: Module.h:369
NestedNameSpecifierLoc ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9001
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:5642
Record code for the table of offsets into the Objective-C method pool.
Definition: ASTBitCodes.h:474
Defines the clang::FileSystemOptions interface.
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2252
ContinuousRangeMap< unsigned, int, 2 > SLocRemap
Definition: ASTUnit.cpp:2322
A DependentSizedArrayType record.
Definition: ASTBitCodes.h:1128
CanQualType UnsignedLongTy
Definition: ASTContext.h:1014
Record code for the remapping information used to relate loaded modules to the various offsets and ID...
Definition: ASTBitCodes.h:569
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
Definition: TemplateBase.h:688
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:135
A key used when looking up entities by DeclarationName.
Definition: ASTBitCodes.h:2057
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
void readModuleFileExtension(const ModuleFileExtensionMetadata &Metadata) override
Indicates that a particular module file extension has been read.
Definition: ASTReader.cpp:247
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
Definition: DeclBase.h:714
Record code for declarations that Sema keeps references of.
Definition: ASTBitCodes.h:520
void ReadTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument array.
Definition: ASTReader.cpp:8842
CanQualType DependentTy
Definition: ASTContext.h:1033
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1991
void * HeaderFileInfoTable
The on-disk hash table that contains information about each of the header files.
Definition: Module.h:359
CanQualType WCharTy
Definition: ASTContext.h:1007
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
Definition: ASTBitCodes.h:151
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:9230
bool hasBody() const override
Determine whether this method has a body.
Definition: DeclObjC.h:526
Offsets into the input-files block where input files reside.
Definition: ASTBitCodes.h:324
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
Definition: ASTReader.cpp:161
CanQualType ObjCBuiltinClassTy
Definition: ASTContext.h:1036
unsigned getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
Definition: DeclBase.h:706
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:819
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1675
PreprocessorRecordTypes
Record types used within a preprocessor block.
Definition: ASTBitCodes.h:680
static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags)
Definition: ASTReader.cpp:486
CanQualType BoundMemberTy
Definition: ASTContext.h:1033
SourceLocation getEnd() const
Definition: ASTBitCodes.h:215
The block containing the submodule structure.
Definition: ASTBitCodes.h:267
QualType getAutoDeductType() const
C++11 deduction pattern for &#39;auto&#39; type.
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
void setTypeArgsRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1014
void ReadTypeLoc(ModuleFile &F, const RecordData &Record, unsigned &Idx, TypeLoc TL)
Raad the type locations for the given TInfo.
Definition: ASTReader.cpp:6770
Wrapper for source info for record types.
Definition: TypeLoc.h:717
std::string BaseDirectory
The base directory of the module.
Definition: Module.h:129
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1936
unsigned CalculateHash()
Definition: ODRHash.cpp:187
The template argument is a type.
Definition: TemplateBase.h:60
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:1339
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
Definition: Module.cpp:207
ContinuousRangeMap< uint32_t, int, 2 > TypeRemap
Remapping table for type IDs in this module.
Definition: Module.h:459
Selector DecodeSelector(serialization::SelectorID Idx)
Definition: ASTReader.cpp:8556
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary
The Objective-C++ ARC standard library that we should support, by providing appropriate definitions t...
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1652
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
Definition: Module.h:331
const TemplateArgumentLoc & getDefaultArgument() const
Retrieve the default argument, if any.
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
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:8585
unsigned BufferOverridden
Indicates whether the buffer itself was provided to override the actual file contents.
void PrintStats() override
Print some statistics about AST usage.
Definition: ASTReader.cpp:7627
void setSeverity(diag::Severity Value)
unsigned size() const
Number of modules loaded.
Defines the clang::TokenKind enum and support functions.
void insert(const value_type &Val)
Metadata for a module file extension.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3532
Keeps track of options that affect how file operations are performed.
CanQualType Char8Ty
Definition: ASTContext.h:1010
llvm::OnDiskIterableChainedHashTable< ASTIdentifierLookupTrait > ASTIdentifierLookupTable
The on-disk hash table used to contain information about all of the identifiers in the program...
StringRef Framework
If this header came from a framework include, this is the name of the framework.
Definition: HeaderSearch.h:112
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2235
static bool ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID)
ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the specified cursor.
Definition: ASTReader.cpp:1544
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
Definition: ASTReader.cpp:6789
A template argument list.
Definition: DeclTemplate.h:210
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1585
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
ExternCContextDecl * getExternCContextDecl() const
IdentifierInfo * DecodeIdentifierInfo(serialization::IdentifierID ID)
Definition: ASTReader.cpp:8364
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition: Type.h:3535
NestedNameSpecifierLoc QualifierLoc
Definition: Decl.h:663
virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain)
Receives the header search options.
Definition: ASTReader.h:182
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II)
getCXXLiteralOperatorName - Get the name of the literal operator function with II as the identifier...
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:2289
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...
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:997
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
Definition: Diagnostic.h:494
The C++ &#39;char16_t&#39; type.
Definition: ASTBitCodes.h:877
Defines the clang::SourceLocation class and associated facilities.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
bool hasRevertedTokenIDToIdentifier() const
True if revertTokenIDToIdentifier() was called.
TemplateArgumentLoc ReadTemplateArgumentLoc(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a TemplateArgumentLoc.
Definition: ASTReader.cpp:7094
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2609
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
Definition: Module.h:240
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:7058
Represents a C++ struct/union/class.
Definition: DeclCXX.h:302
Selector GetExternalSelector(serialization::SelectorID ID) override
Resolve a selector ID into a selector.
Definition: ASTReader.cpp:8581
static const ASTTemplateArgumentListInfo * Create(ASTContext &C, const TemplateArgumentListInfo &List)
bool isValid() const
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:7392
virtual bool needsSystemInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
Definition: ASTReader.h:216
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl *> &Decls) override
Read the set of unused file-scope declarations known to the external Sema source. ...
Definition: ASTReader.cpp:8172
An TemplateTypeParmType record.
Definition: ASTBitCodes.h:1116
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
bool needsSystemInputFileVisitation() override
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
Definition: ASTReader.cpp:220
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Definition: ExprCXX.cpp:763
SmallVector< uint64_t, 8 > PragmaDiagMappings
Diagnostic IDs and their mappings that the user changed.
Definition: Module.h:464
Record code for the filesystem options table.
Definition: ASTBitCodes.h:352
static hash_value_type ComputeHash(const internal_key_type &a)
Definition: ASTReader.cpp:884
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
Definition: ASTReader.cpp:1561
const char * IdentifierTableData
Actual data for the on-disk hash table of identifiers.
Definition: Module.h:285
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1478
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
Definition: ASTCommon.cpp:404
CanQualType Char16Ty
Definition: ASTContext.h:1011
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:152
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...
unsigned getNumProtocols() const
Definition: TypeLoc.h:1048
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1170
const DeclOffset * DeclOffsets
Offset of each declaration within the bitstream, indexed by the declaration ID (-1).
Definition: Module.h:413
Location information for a TemplateArgument.
Definition: TemplateBase.h:393
virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the target options.
Definition: ASTReader.h:154
Declaration of a class template.
Record code for the offsets of each type.
Definition: ASTBitCodes.h:403
A DependentAddressSpaceType record.
Definition: ASTBitCodes.h:1170
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:2859
The block containing the definitions of all of the types and decls used within the AST file...
Definition: ASTBitCodes.h:261
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
The internal &#39;__va_list_tag&#39; struct, if any.
Definition: ASTBitCodes.h:1248
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
void revertTokenIDToIdentifier()
Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 compatibility.
virtual void ReadModuleName(StringRef ModuleName)
Definition: ASTReader.h:138
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C &#39;Class&#39; type...
bool hasAttrOperand() const
Definition: TypeLoc.h:878
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:266
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
Definition: ASTReader.cpp:555
ASTIdentifierIterator(const ASTReader &Reader, bool SkipModules=false)
Definition: ASTReader.cpp:7929
void resolveLinkAsDependencies(Module *Mod)
Use PendingLinkAsModule information to mark top level link names that are going to be replaced by exp...
Definition: ModuleMap.cpp:57
The module file had already been loaded.
Specifies the name of the module that will eventually re-export the entities in this module...
Definition: ASTBitCodes.h:781
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1585
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:393
TypeLocReader(ModuleFile &F, ASTReader &Reader, const ASTReader::RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:6459
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:267
void setPrevious(MacroDirective *Prev)
Set previous definition of the macro with the same name.
Definition: MacroInfo.h:326
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1948
The (signed) &#39;int&#39; type.
Definition: ASTBitCodes.h:844
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:3567
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1645
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
std::pair< ObjCMethodList, ObjCMethodList > GlobalMethods
Definition: Sema.h:1124
data_type ReadData(const internal_key_type &k, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:936
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
Specifies a required feature.
Definition: ASTBitCodes.h:749
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
SourceLocation getSourceLocationForDeclID(serialization::GlobalDeclID ID)
Returns the source location for the decl ID.
Definition: ASTReader.cpp:7254
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:344
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:149
unsigned getNumTypeArgs() const
Definition: TypeLoc.h:1018
__DEVICE__ int max(int __a, int __b)
CanQualType IntTy
Definition: ASTContext.h:1013
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:396
Record for offsets of DECL_UPDATES records for declarations that were modified after being deserializ...
Definition: ASTBitCodes.h:537
unsigned ModuleMapFileHomeIsCwd
Set the &#39;home directory&#39; 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:493
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:4725
llvm::BitstreamCursor PreprocessorDetailCursor
The cursor to the start of the (optional) detailed preprocessing record block.
Definition: Module.h:324
The C++ &#39;wchar_t&#39; type.
Definition: ASTBitCodes.h:838
The ObjC &#39;Class&#39; type.
Definition: ASTBitCodes.h:886
void setProtocolLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1036
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1120
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 &#39;type...
unsigned IndexHeaderMapHeader
Whether this is a header inside a framework that is currently being built.
Definition: HeaderSearch.h:85
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:7246
unsigned IsValid
Whether this file has been looked up as a header.
Definition: HeaderSearch.h:88
static bool isWhitelistedDecl(const Decl *D, const DeclContext *Parent)
Definition: ODRHash.cpp:420
Record code for weak undeclared identifiers.
Definition: ASTBitCodes.h:523
The block containing information about the preprocessor.
Definition: ASTBitCodes.h:257
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, const TemplateArgumentListInfo &Args) const
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:757
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:7617
QualType getDefaultArgument() const
Retrieve the default argument, if any.
void setLocation(SourceLocation L)
Definition: Token.h:132
bool getWarningsAsErrors() const
Definition: Diagnostic.h:609
QualType getType() const
Definition: Decl.h:648
Wrapper for source info for builtin types.
Definition: TypeLoc.h:545
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1174
A set of overloaded template declarations.
Definition: TemplateName.h:194
Wrapper for template type parameters.
Definition: TypeLoc.h:733
Record code for the headers search options table.
Definition: ASTBitCodes.h:355
Module * Other
The module that this module conflicts with.
Definition: Module.h:362
A trivial tuple used to represent a source range.
void setParameterList(ArrayRef< IdentifierInfo *> List, llvm::BumpPtrAllocator &PPAllocator)
Set the specified list of identifiers as the parameter list for this macro.
Definition: MacroInfo.h:165
This represents a decl that may have a name.
Definition: Decl.h:248
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
Definition: ASTContext.h:1746
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
Definition: ASTContext.h:1724
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
AST file metadata, including the AST file version number and information about the compiler used to b...
Definition: ASTBitCodes.h:304
The block of input files, which were used as inputs to create this AST file.
Definition: ASTBitCodes.h:281
static DeclarationName getUsingDirectiveName()
getUsingDirectiveName - Return name for all using-directives.
Present this diagnostic as a warning.
llvm::BitstreamCursor MacroCursor
The cursor to the start of the preprocessor block, which stores all of the macro definitions.
Definition: Module.h:299
const uint32_t * SelectorOffsets
Offsets into the selector lookup table&#39;s data array where each selector resides.
Definition: Module.h:381
CanQualType BoolTy
Definition: ASTContext.h:1005
void UpdateSema()
Update the state of Sema after loading some additional modules.
Definition: ASTReader.cpp:7800
unsigned LocalNumTypes
The number of types in this AST file.
Definition: Module.h:448
Represents a C++ namespace alias.
Definition: DeclCXX.h:3028
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1669
Kind
The basic Objective-C runtimes that we know about.
Definition: ObjCRuntime.h:31
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...
The internal &#39;__NSConstantString&#39; tag type.
Definition: ASTBitCodes.h:1263
static TypeIdx fromTypeID(TypeID ID)
Definition: ASTBitCodes.h:105
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:7375
InputFileRecordTypes
Record types that occur within the input-files block inside the control block.
Definition: ASTBitCodes.h:384
void FinishedDeserializing() override
Notify ASTReader that we finished the deserialization of a decl or type.
CanQualType DoubleTy
Definition: ASTContext.h:1016
A function-like macro definition.
Definition: ASTBitCodes.h:691
~ASTReader() override
The Objective-C &#39;Protocol&#39; type.
Definition: ASTBitCodes.h:1233
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
The global specifier &#39;::&#39;. There is no stored value.
The control block, which contains all of the information that needs to be validated prior to committi...
Definition: ASTBitCodes.h:275
Wrapper for source info for pointers.
Definition: TypeLoc.h:1271
SourceLocation getBegin() const
const FileEntry * File
The file entry for the module file.
Definition: Module.h:164
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
void setObjCOrBuiltinID(unsigned ID)
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1284
void ReadModuleName(StringRef ModuleName) override
Definition: ASTReader.cpp:150
The &#39;_Sat unsigned short _Fract&#39; type.
Definition: ASTBitCodes.h:1006
bool isSystem(CharacteristicKind CK)
Determine whether a file / directory characteristic is for system code.
Definition: SourceManager.h:83
This class handles loading and caching of source files into memory.
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3557
PredefinedDeclIDs
Predefined declaration IDs.
Definition: ASTBitCodes.h:1216
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
Declaration of a template function.
Definition: DeclTemplate.h:968
Record code for an update to the TU&#39;s lexically contained declarations.
Definition: ASTBitCodes.h:515
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3236
The &#39;_Sat _Fract&#39; type.
Definition: ASTBitCodes.h:1000
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2012
Source range/offset of a preprocessed entity.
Definition: ASTBitCodes.h:221
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind) override
This is called for each AST file loaded.
Definition: ASTReader.cpp:225
bool isDeletedAsWritten() const
Definition: Decl.h:2126
SourceLocation getLocation() const
Definition: DeclBase.h:419
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID...
Definition: Module.h:436
bool loadGlobalIndex()
Attempts to load the global index.
Definition: ASTReader.cpp:3803
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:8488
Objective-C "Class" redefinition type.
Definition: ASTBitCodes.h:1198
A PackExpansionType record.
Definition: ASTBitCodes.h:1134
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
Definition: ASTReader.cpp:8204
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
A single template declaration.
Definition: TemplateName.h:191
CanQualType OCLClkEventTy
Definition: ASTContext.h:1041
The pseudo-object placeholder type.
Definition: ASTBitCodes.h:910
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
Definition: ASTBitCodes.h:175
virtual bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain)
Receives the diagnostic options.
Definition: ASTReader.h:164
void setUnderlyingTInfo(TypeSourceInfo *TI) const
Definition: TypeLoc.h:1914
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Definition: Module.h:244
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
Record code for #pragma ms_struct options.
Definition: ASTBitCodes.h:630
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
Definition: ASTReader.cpp:9144
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
A DependentTemplateSpecializationType record.
Definition: ASTBitCodes.h:1125
CanQualType UnsignedIntTy
Definition: ASTContext.h:1014
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...
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.
bool ParseAllComments
Treat ordinary comments as documentation comments.
serialization::IdentifierID getGlobalIdentifierID(ModuleFile &M, unsigned LocalID)
Definition: ASTReader.cpp:8403
Record code for the array of tentative definitions.
Definition: ASTBitCodes.h:468
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
The &#39;__float128&#39; type.
Definition: ASTBitCodes.h:934
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.