clang  6.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"
66 #include "clang/Lex/HeaderSearch.h"
68 #include "clang/Lex/MacroInfo.h"
69 #include "clang/Lex/ModuleMap.h"
71 #include "clang/Lex/Preprocessor.h"
73 #include "clang/Lex/Token.h"
75 #include "clang/Sema/Scope.h"
76 #include "clang/Sema/Sema.h"
77 #include "clang/Sema/Weak.h"
86 #include "llvm/ADT/APFloat.h"
87 #include "llvm/ADT/APInt.h"
88 #include "llvm/ADT/APSInt.h"
89 #include "llvm/ADT/ArrayRef.h"
90 #include "llvm/ADT/DenseMap.h"
91 #include "llvm/ADT/FoldingSet.h"
92 #include "llvm/ADT/Hashing.h"
93 #include "llvm/ADT/IntrusiveRefCntPtr.h"
94 #include "llvm/ADT/None.h"
95 #include "llvm/ADT/Optional.h"
96 #include "llvm/ADT/STLExtras.h"
97 #include "llvm/ADT/SmallPtrSet.h"
98 #include "llvm/ADT/SmallString.h"
99 #include "llvm/ADT/SmallVector.h"
100 #include "llvm/ADT/StringExtras.h"
101 #include "llvm/ADT/StringMap.h"
102 #include "llvm/ADT/StringRef.h"
103 #include "llvm/ADT/Triple.h"
104 #include "llvm/ADT/iterator_range.h"
105 #include "llvm/Bitcode/BitstreamReader.h"
106 #include "llvm/Support/Casting.h"
107 #include "llvm/Support/Compression.h"
108 #include "llvm/Support/Compiler.h"
109 #include "llvm/Support/Endian.h"
110 #include "llvm/Support/Error.h"
111 #include "llvm/Support/ErrorHandling.h"
112 #include "llvm/Support/FileSystem.h"
113 #include "llvm/Support/MemoryBuffer.h"
114 #include "llvm/Support/Path.h"
115 #include "llvm/Support/SaveAndRestore.h"
116 #include "llvm/Support/Timer.h"
117 #include "llvm/Support/raw_ostream.h"
118 #include <algorithm>
119 #include <cassert>
120 #include <cstddef>
121 #include <cstdint>
122 #include <cstdio>
123 #include <ctime>
124 #include <iterator>
125 #include <limits>
126 #include <map>
127 #include <memory>
128 #include <string>
129 #include <system_error>
130 #include <tuple>
131 #include <utility>
132 #include <vector>
133 
134 using namespace clang;
135 using namespace clang::serialization;
136 using namespace clang::serialization::reader;
137 using llvm::BitstreamCursor;
138 
139 //===----------------------------------------------------------------------===//
140 // ChainedASTReaderListener implementation
141 //===----------------------------------------------------------------------===//
142 
143 bool
145  return First->ReadFullVersionInformation(FullVersion) ||
146  Second->ReadFullVersionInformation(FullVersion);
147 }
148 
149 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
150  First->ReadModuleName(ModuleName);
151  Second->ReadModuleName(ModuleName);
152 }
153 
154 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
155  First->ReadModuleMapFile(ModuleMapPath);
156  Second->ReadModuleMapFile(ModuleMapPath);
157 }
158 
159 bool
161  bool Complain,
162  bool AllowCompatibleDifferences) {
163  return First->ReadLanguageOptions(LangOpts, Complain,
164  AllowCompatibleDifferences) ||
165  Second->ReadLanguageOptions(LangOpts, Complain,
166  AllowCompatibleDifferences);
167 }
168 
170  const TargetOptions &TargetOpts, bool Complain,
171  bool AllowCompatibleDifferences) {
172  return First->ReadTargetOptions(TargetOpts, Complain,
173  AllowCompatibleDifferences) ||
174  Second->ReadTargetOptions(TargetOpts, Complain,
175  AllowCompatibleDifferences);
176 }
177 
179  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
180  return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
181  Second->ReadDiagnosticOptions(DiagOpts, Complain);
182 }
183 
184 bool
186  bool Complain) {
187  return First->ReadFileSystemOptions(FSOpts, Complain) ||
188  Second->ReadFileSystemOptions(FSOpts, Complain);
189 }
190 
192  const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
193  bool Complain) {
194  return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
195  Complain) ||
196  Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
197  Complain);
198 }
199 
201  const PreprocessorOptions &PPOpts, bool Complain,
202  std::string &SuggestedPredefines) {
203  return First->ReadPreprocessorOptions(PPOpts, Complain,
204  SuggestedPredefines) ||
205  Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
206 }
207 
209  unsigned Value) {
210  First->ReadCounter(M, Value);
211  Second->ReadCounter(M, Value);
212 }
213 
215  return First->needsInputFileVisitation() ||
216  Second->needsInputFileVisitation();
217 }
218 
220  return First->needsSystemInputFileVisitation() ||
221  Second->needsSystemInputFileVisitation();
222 }
223 
225  ModuleKind Kind) {
226  First->visitModuleFile(Filename, Kind);
227  Second->visitModuleFile(Filename, Kind);
228 }
229 
231  bool isSystem,
232  bool isOverridden,
233  bool isExplicitModule) {
234  bool Continue = false;
235  if (First->needsInputFileVisitation() &&
236  (!isSystem || First->needsSystemInputFileVisitation()))
237  Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
238  isExplicitModule);
239  if (Second->needsInputFileVisitation() &&
240  (!isSystem || Second->needsSystemInputFileVisitation()))
241  Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
242  isExplicitModule);
243  return Continue;
244 }
245 
247  const ModuleFileExtensionMetadata &Metadata) {
248  First->readModuleFileExtension(Metadata);
249  Second->readModuleFileExtension(Metadata);
250 }
251 
252 //===----------------------------------------------------------------------===//
253 // PCH validator implementation
254 //===----------------------------------------------------------------------===//
255 
257 
258 /// \brief Compare the given set of language options against an existing set of
259 /// language options.
260 ///
261 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
262 /// \param AllowCompatibleDifferences If true, differences between compatible
263 /// language options will be permitted.
264 ///
265 /// \returns true if the languagae options mis-match, false otherwise.
266 static bool checkLanguageOptions(const LangOptions &LangOpts,
267  const LangOptions &ExistingLangOpts,
268  DiagnosticsEngine *Diags,
269  bool AllowCompatibleDifferences = true) {
270 #define LANGOPT(Name, Bits, Default, Description) \
271  if (ExistingLangOpts.Name != LangOpts.Name) { \
272  if (Diags) \
273  Diags->Report(diag::err_pch_langopt_mismatch) \
274  << Description << LangOpts.Name << ExistingLangOpts.Name; \
275  return true; \
276  }
277 
278 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
279  if (ExistingLangOpts.Name != LangOpts.Name) { \
280  if (Diags) \
281  Diags->Report(diag::err_pch_langopt_value_mismatch) \
282  << Description; \
283  return true; \
284  }
285 
286 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
287  if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
288  if (Diags) \
289  Diags->Report(diag::err_pch_langopt_value_mismatch) \
290  << Description; \
291  return true; \
292  }
293 
294 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
295  if (!AllowCompatibleDifferences) \
296  LANGOPT(Name, Bits, Default, Description)
297 
298 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
299  if (!AllowCompatibleDifferences) \
300  ENUM_LANGOPT(Name, Bits, Default, Description)
301 
302 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
303  if (!AllowCompatibleDifferences) \
304  VALUE_LANGOPT(Name, Bits, Default, Description)
305 
306 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
307 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
308 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
309 #include "clang/Basic/LangOptions.def"
310 
311  if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
312  if (Diags)
313  Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
314  return true;
315  }
316 
317  if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
318  if (Diags)
319  Diags->Report(diag::err_pch_langopt_value_mismatch)
320  << "target Objective-C runtime";
321  return true;
322  }
323 
324  if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
325  LangOpts.CommentOpts.BlockCommandNames) {
326  if (Diags)
327  Diags->Report(diag::err_pch_langopt_value_mismatch)
328  << "block command names";
329  return true;
330  }
331 
332  // Sanitizer feature mismatches are treated as compatible differences. If
333  // compatible differences aren't allowed, we still only want to check for
334  // mismatches of non-modular sanitizers (the only ones which can affect AST
335  // generation).
336  if (!AllowCompatibleDifferences) {
337  SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
338  SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
339  SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
340  ExistingSanitizers.clear(ModularSanitizers);
341  ImportedSanitizers.clear(ModularSanitizers);
342  if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
343  const std::string Flag = "-fsanitize=";
344  if (Diags) {
345 #define SANITIZER(NAME, ID) \
346  { \
347  bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
348  bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
349  if (InExistingModule != InImportedModule) \
350  Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
351  << InExistingModule << (Flag + NAME); \
352  }
353 #include "clang/Basic/Sanitizers.def"
354  }
355  return true;
356  }
357  }
358 
359  return false;
360 }
361 
362 /// \brief Compare the given set of target options against an existing set of
363 /// target options.
364 ///
365 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
366 ///
367 /// \returns true if the target options mis-match, false otherwise.
368 static bool checkTargetOptions(const TargetOptions &TargetOpts,
369  const TargetOptions &ExistingTargetOpts,
370  DiagnosticsEngine *Diags,
371  bool AllowCompatibleDifferences = true) {
372 #define CHECK_TARGET_OPT(Field, Name) \
373  if (TargetOpts.Field != ExistingTargetOpts.Field) { \
374  if (Diags) \
375  Diags->Report(diag::err_pch_targetopt_mismatch) \
376  << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
377  return true; \
378  }
379 
380  // The triple and ABI must match exactly.
381  CHECK_TARGET_OPT(Triple, "target");
382  CHECK_TARGET_OPT(ABI, "target ABI");
383 
384  // We can tolerate different CPUs in many cases, notably when one CPU
385  // supports a strict superset of another. When allowing compatible
386  // differences skip this check.
387  if (!AllowCompatibleDifferences)
388  CHECK_TARGET_OPT(CPU, "target CPU");
389 
390 #undef CHECK_TARGET_OPT
391 
392  // Compare feature sets.
393  SmallVector<StringRef, 4> ExistingFeatures(
394  ExistingTargetOpts.FeaturesAsWritten.begin(),
395  ExistingTargetOpts.FeaturesAsWritten.end());
396  SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
397  TargetOpts.FeaturesAsWritten.end());
398  std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
399  std::sort(ReadFeatures.begin(), ReadFeatures.end());
400 
401  // We compute the set difference in both directions explicitly so that we can
402  // diagnose the differences differently.
403  SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
404  std::set_difference(
405  ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
406  ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
407  std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
408  ExistingFeatures.begin(), ExistingFeatures.end(),
409  std::back_inserter(UnmatchedReadFeatures));
410 
411  // If we are allowing compatible differences and the read feature set is
412  // a strict subset of the existing feature set, there is nothing to diagnose.
413  if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
414  return false;
415 
416  if (Diags) {
417  for (StringRef Feature : UnmatchedReadFeatures)
418  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
419  << /* is-existing-feature */ false << Feature;
420  for (StringRef Feature : UnmatchedExistingFeatures)
421  Diags->Report(diag::err_pch_targetopt_feature_mismatch)
422  << /* is-existing-feature */ true << Feature;
423  }
424 
425  return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
426 }
427 
428 bool
430  bool Complain,
431  bool AllowCompatibleDifferences) {
432  const LangOptions &ExistingLangOpts = PP.getLangOpts();
433  return checkLanguageOptions(LangOpts, ExistingLangOpts,
434  Complain ? &Reader.Diags : nullptr,
435  AllowCompatibleDifferences);
436 }
437 
439  bool Complain,
440  bool AllowCompatibleDifferences) {
441  const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
442  return checkTargetOptions(TargetOpts, ExistingTargetOpts,
443  Complain ? &Reader.Diags : nullptr,
444  AllowCompatibleDifferences);
445 }
446 
447 namespace {
448 
449 using MacroDefinitionsMap =
450  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
451 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
452 
453 } // namespace
454 
456  DiagnosticsEngine &Diags,
457  bool Complain) {
459 
460  // Check current mappings for new -Werror mappings, and the stored mappings
461  // for cases that were explicitly mapped to *not* be errors that are now
462  // errors because of options like -Werror.
463  DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
464 
465  for (DiagnosticsEngine *MappingSource : MappingSources) {
466  for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
467  diag::kind DiagID = DiagIDMappingPair.first;
468  Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
469  if (CurLevel < DiagnosticsEngine::Error)
470  continue; // not significant
471  Level StoredLevel =
472  StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
473  if (StoredLevel < DiagnosticsEngine::Error) {
474  if (Complain)
475  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
476  Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
477  return true;
478  }
479  }
480  }
481 
482  return false;
483 }
484 
487  if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
488  return true;
489  return Ext >= diag::Severity::Error;
490 }
491 
493  DiagnosticsEngine &Diags,
494  bool IsSystem, bool Complain) {
495  // Top-level options
496  if (IsSystem) {
497  if (Diags.getSuppressSystemWarnings())
498  return false;
499  // If -Wsystem-headers was not enabled before, be conservative
500  if (StoredDiags.getSuppressSystemWarnings()) {
501  if (Complain)
502  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
503  return true;
504  }
505  }
506 
507  if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
508  if (Complain)
509  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
510  return true;
511  }
512 
513  if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
514  !StoredDiags.getEnableAllWarnings()) {
515  if (Complain)
516  Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
517  return true;
518  }
519 
520  if (isExtHandlingFromDiagsError(Diags) &&
521  !isExtHandlingFromDiagsError(StoredDiags)) {
522  if (Complain)
523  Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
524  return true;
525  }
526 
527  return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
528 }
529 
530 /// Return the top import module if it is implicit, nullptr otherwise.
532  Preprocessor &PP) {
533  // If the original import came from a file explicitly generated by the user,
534  // don't check the diagnostic mappings.
535  // FIXME: currently this is approximated by checking whether this is not a
536  // module import of an implicitly-loaded module file.
537  // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
538  // the transitive closure of its imports, since unrelated modules cannot be
539  // imported until after this module finishes validation.
540  ModuleFile *TopImport = &*ModuleMgr.rbegin();
541  while (!TopImport->ImportedBy.empty())
542  TopImport = TopImport->ImportedBy[0];
543  if (TopImport->Kind != MK_ImplicitModule)
544  return nullptr;
545 
546  StringRef ModuleName = TopImport->ModuleName;
547  assert(!ModuleName.empty() && "diagnostic options read before module name");
548 
549  Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
550  assert(M && "missing module");
551  return M;
552 }
553 
555  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
556  DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
557  IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
559  new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
560  // This should never fail, because we would have processed these options
561  // before writing them to an ASTFile.
562  ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
563 
564  ModuleManager &ModuleMgr = Reader.getModuleManager();
565  assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
566 
567  Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
568  if (!TopM)
569  return false;
570 
571  // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
572  // contains the union of their flags.
573  return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
574  Complain);
575 }
576 
577 /// \brief Collect the macro definitions provided by the given preprocessor
578 /// options.
579 static void
581  MacroDefinitionsMap &Macros,
582  SmallVectorImpl<StringRef> *MacroNames = nullptr) {
583  for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
584  StringRef Macro = PPOpts.Macros[I].first;
585  bool IsUndef = PPOpts.Macros[I].second;
586 
587  std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
588  StringRef MacroName = MacroPair.first;
589  StringRef MacroBody = MacroPair.second;
590 
591  // For an #undef'd macro, we only care about the name.
592  if (IsUndef) {
593  if (MacroNames && !Macros.count(MacroName))
594  MacroNames->push_back(MacroName);
595 
596  Macros[MacroName] = std::make_pair("", true);
597  continue;
598  }
599 
600  // For a #define'd macro, figure out the actual definition.
601  if (MacroName.size() == Macro.size())
602  MacroBody = "1";
603  else {
604  // Note: GCC drops anything following an end-of-line character.
605  StringRef::size_type End = MacroBody.find_first_of("\n\r");
606  MacroBody = MacroBody.substr(0, End);
607  }
608 
609  if (MacroNames && !Macros.count(MacroName))
610  MacroNames->push_back(MacroName);
611  Macros[MacroName] = std::make_pair(MacroBody, false);
612  }
613 }
614 
615 /// \brief Check the preprocessor options deserialized from the control block
616 /// against the preprocessor options in an existing preprocessor.
617 ///
618 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
619 /// \param Validate If true, validate preprocessor options. If false, allow
620 /// macros defined by \p ExistingPPOpts to override those defined by
621 /// \p PPOpts in SuggestedPredefines.
623  const PreprocessorOptions &ExistingPPOpts,
624  DiagnosticsEngine *Diags,
625  FileManager &FileMgr,
626  std::string &SuggestedPredefines,
627  const LangOptions &LangOpts,
628  bool Validate = true) {
629  // Check macro definitions.
630  MacroDefinitionsMap ASTFileMacros;
631  collectMacroDefinitions(PPOpts, ASTFileMacros);
632  MacroDefinitionsMap ExistingMacros;
633  SmallVector<StringRef, 4> ExistingMacroNames;
634  collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
635 
636  for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
637  // Dig out the macro definition in the existing preprocessor options.
638  StringRef MacroName = ExistingMacroNames[I];
639  std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
640 
641  // Check whether we know anything about this macro name or not.
642  llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
643  ASTFileMacros.find(MacroName);
644  if (!Validate || Known == ASTFileMacros.end()) {
645  // FIXME: Check whether this identifier was referenced anywhere in the
646  // AST file. If so, we should reject the AST file. Unfortunately, this
647  // information isn't in the control block. What shall we do about it?
648 
649  if (Existing.second) {
650  SuggestedPredefines += "#undef ";
651  SuggestedPredefines += MacroName.str();
652  SuggestedPredefines += '\n';
653  } else {
654  SuggestedPredefines += "#define ";
655  SuggestedPredefines += MacroName.str();
656  SuggestedPredefines += ' ';
657  SuggestedPredefines += Existing.first.str();
658  SuggestedPredefines += '\n';
659  }
660  continue;
661  }
662 
663  // If the macro was defined in one but undef'd in the other, we have a
664  // conflict.
665  if (Existing.second != Known->second.second) {
666  if (Diags) {
667  Diags->Report(diag::err_pch_macro_def_undef)
668  << MacroName << Known->second.second;
669  }
670  return true;
671  }
672 
673  // If the macro was #undef'd in both, or if the macro bodies are identical,
674  // it's fine.
675  if (Existing.second || Existing.first == Known->second.first)
676  continue;
677 
678  // The macro bodies differ; complain.
679  if (Diags) {
680  Diags->Report(diag::err_pch_macro_def_conflict)
681  << MacroName << Known->second.first << Existing.first;
682  }
683  return true;
684  }
685 
686  // Check whether we're using predefines.
687  if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
688  if (Diags) {
689  Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
690  }
691  return true;
692  }
693 
694  // Detailed record is important since it is used for the module cache hash.
695  if (LangOpts.Modules &&
696  PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
697  if (Diags) {
698  Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
699  }
700  return true;
701  }
702 
703  // Compute the #include and #include_macros lines we need.
704  for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
705  StringRef File = ExistingPPOpts.Includes[I];
706  if (File == ExistingPPOpts.ImplicitPCHInclude)
707  continue;
708 
709  if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
710  != PPOpts.Includes.end())
711  continue;
712 
713  SuggestedPredefines += "#include \"";
714  SuggestedPredefines += File;
715  SuggestedPredefines += "\"\n";
716  }
717 
718  for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
719  StringRef File = ExistingPPOpts.MacroIncludes[I];
720  if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
721  File)
722  != PPOpts.MacroIncludes.end())
723  continue;
724 
725  SuggestedPredefines += "#__include_macros \"";
726  SuggestedPredefines += File;
727  SuggestedPredefines += "\"\n##\n";
728  }
729 
730  return false;
731 }
732 
734  bool Complain,
735  std::string &SuggestedPredefines) {
736  const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
737 
738  return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
739  Complain? &Reader.Diags : nullptr,
740  PP.getFileManager(),
741  SuggestedPredefines,
742  PP.getLangOpts());
743 }
744 
746  const PreprocessorOptions &PPOpts,
747  bool Complain,
748  std::string &SuggestedPredefines) {
749  return checkPreprocessorOptions(PPOpts,
750  PP.getPreprocessorOpts(),
751  nullptr,
752  PP.getFileManager(),
753  SuggestedPredefines,
754  PP.getLangOpts(),
755  false);
756 }
757 
758 /// Check the header search options deserialized from the control block
759 /// against the header search options in an existing preprocessor.
760 ///
761 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
763  StringRef SpecificModuleCachePath,
764  StringRef ExistingModuleCachePath,
765  DiagnosticsEngine *Diags,
766  const LangOptions &LangOpts) {
767  if (LangOpts.Modules) {
768  if (SpecificModuleCachePath != ExistingModuleCachePath) {
769  if (Diags)
770  Diags->Report(diag::err_pch_modulecache_mismatch)
771  << SpecificModuleCachePath << ExistingModuleCachePath;
772  return true;
773  }
774  }
775 
776  return false;
777 }
778 
780  StringRef SpecificModuleCachePath,
781  bool Complain) {
782  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
783  PP.getHeaderSearchInfo().getModuleCachePath(),
784  Complain ? &Reader.Diags : nullptr,
785  PP.getLangOpts());
786 }
787 
788 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
789  PP.setCounterValue(Value);
790 }
791 
792 //===----------------------------------------------------------------------===//
793 // AST reader implementation
794 //===----------------------------------------------------------------------===//
795 
797  bool TakeOwnership) {
798  DeserializationListener = Listener;
799  OwnsDeserializationListener = TakeOwnership;
800 }
801 
803  return serialization::ComputeHash(Sel);
804 }
805 
806 std::pair<unsigned, unsigned>
808  using namespace llvm::support;
809 
810  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
811  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
812  return std::make_pair(KeyLen, DataLen);
813 }
814 
816 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
817  using namespace llvm::support;
818 
819  SelectorTable &SelTable = Reader.getContext().Selectors;
820  unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
821  IdentifierInfo *FirstII = Reader.getLocalIdentifier(
822  F, endian::readNext<uint32_t, little, unaligned>(d));
823  if (N == 0)
824  return SelTable.getNullarySelector(FirstII);
825  else if (N == 1)
826  return SelTable.getUnarySelector(FirstII);
827 
829  Args.push_back(FirstII);
830  for (unsigned I = 1; I != N; ++I)
831  Args.push_back(Reader.getLocalIdentifier(
832  F, endian::readNext<uint32_t, little, unaligned>(d)));
833 
834  return SelTable.getSelector(N, Args.data());
835 }
836 
839  unsigned DataLen) {
840  using namespace llvm::support;
841 
842  data_type Result;
843 
844  Result.ID = Reader.getGlobalSelectorID(
845  F, endian::readNext<uint32_t, little, unaligned>(d));
846  unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
847  unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
848  Result.InstanceBits = FullInstanceBits & 0x3;
849  Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
850  Result.FactoryBits = FullFactoryBits & 0x3;
851  Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
852  unsigned NumInstanceMethods = FullInstanceBits >> 3;
853  unsigned NumFactoryMethods = FullFactoryBits >> 3;
854 
855  // Load instance methods
856  for (unsigned I = 0; I != NumInstanceMethods; ++I) {
857  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
858  F, endian::readNext<uint32_t, little, unaligned>(d)))
859  Result.Instance.push_back(Method);
860  }
861 
862  // Load factory methods
863  for (unsigned I = 0; I != NumFactoryMethods; ++I) {
864  if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
865  F, endian::readNext<uint32_t, little, unaligned>(d)))
866  Result.Factory.push_back(Method);
867  }
868 
869  return Result;
870 }
871 
873  return llvm::HashString(a);
874 }
875 
876 std::pair<unsigned, unsigned>
878  using namespace llvm::support;
879 
880  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
881  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
882  return std::make_pair(KeyLen, DataLen);
883 }
884 
886 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
887  assert(n >= 2 && d[n-1] == '\0');
888  return StringRef((const char*) d, n-1);
889 }
890 
891 /// \brief Whether the given identifier is "interesting".
893  bool IsModule) {
894  return II.hadMacroDefinition() ||
895  II.isPoisoned() ||
896  (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
898  (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
899  II.getFETokenInfo<void>());
900 }
901 
902 static bool readBit(unsigned &Bits) {
903  bool Value = Bits & 0x1;
904  Bits >>= 1;
905  return Value;
906 }
907 
909  using namespace llvm::support;
910 
911  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
912  return Reader.getGlobalIdentifierID(F, RawID >> 1);
913 }
914 
915 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
916  if (!II.isFromAST()) {
917  II.setIsFromAST();
918  bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
919  if (isInterestingIdentifier(Reader, II, IsModule))
921  }
922 }
923 
925  const unsigned char* d,
926  unsigned DataLen) {
927  using namespace llvm::support;
928 
929  unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
930  bool IsInteresting = RawID & 0x01;
931 
932  // Wipe out the "is interesting" bit.
933  RawID = RawID >> 1;
934 
935  // Build the IdentifierInfo and link the identifier ID with it.
936  IdentifierInfo *II = KnownII;
937  if (!II) {
938  II = &Reader.getIdentifierTable().getOwn(k);
939  KnownII = II;
940  }
941  markIdentifierFromAST(Reader, *II);
942  Reader.markIdentifierUpToDate(II);
943 
944  IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
945  if (!IsInteresting) {
946  // For uninteresting identifiers, there's nothing else to do. Just notify
947  // the reader that we've finished loading this identifier.
948  Reader.SetIdentifierInfo(ID, II);
949  return II;
950  }
951 
952  unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
953  unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
954  bool CPlusPlusOperatorKeyword = readBit(Bits);
955  bool HasRevertedTokenIDToIdentifier = readBit(Bits);
956  bool HasRevertedBuiltin = readBit(Bits);
957  bool Poisoned = readBit(Bits);
958  bool ExtensionToken = readBit(Bits);
959  bool HadMacroDefinition = readBit(Bits);
960 
961  assert(Bits == 0 && "Extra bits in the identifier?");
962  DataLen -= 8;
963 
964  // Set or check the various bits in the IdentifierInfo structure.
965  // Token IDs are read-only.
966  if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
968  if (!F.isModule())
969  II->setObjCOrBuiltinID(ObjCOrBuiltinID);
970  else if (HasRevertedBuiltin && II->getBuiltinID()) {
971  II->revertBuiltin();
972  assert((II->hasRevertedBuiltin() ||
973  II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
974  "Incorrect ObjC keyword or builtin ID");
975  }
976  assert(II->isExtensionToken() == ExtensionToken &&
977  "Incorrect extension token flag");
978  (void)ExtensionToken;
979  if (Poisoned)
980  II->setIsPoisoned(true);
981  assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
982  "Incorrect C++ operator keyword flag");
983  (void)CPlusPlusOperatorKeyword;
984 
985  // If this identifier is a macro, deserialize the macro
986  // definition.
987  if (HadMacroDefinition) {
988  uint32_t MacroDirectivesOffset =
989  endian::readNext<uint32_t, little, unaligned>(d);
990  DataLen -= 4;
991 
992  Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
993  }
994 
995  Reader.SetIdentifierInfo(ID, II);
996 
997  // Read all of the declarations visible at global scope with this
998  // name.
999  if (DataLen > 0) {
1000  SmallVector<uint32_t, 4> DeclIDs;
1001  for (; DataLen > 0; DataLen -= 4)
1002  DeclIDs.push_back(Reader.getGlobalDeclID(
1003  F, endian::readNext<uint32_t, little, unaligned>(d)));
1004  Reader.SetGloballyVisibleDecls(II, DeclIDs);
1005  }
1006 
1007  return II;
1008 }
1009 
1011  : Kind(Name.getNameKind()) {
1012  switch (Kind) {
1014  Data = (uint64_t)Name.getAsIdentifierInfo();
1015  break;
1019  Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1020  break;
1022  Data = Name.getCXXOverloadedOperator();
1023  break;
1025  Data = (uint64_t)Name.getCXXLiteralIdentifier();
1026  break;
1028  Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1030  break;
1035  Data = 0;
1036  break;
1037  }
1038 }
1039 
1041  llvm::FoldingSetNodeID ID;
1042  ID.AddInteger(Kind);
1043 
1044  switch (Kind) {
1048  ID.AddString(((IdentifierInfo*)Data)->getName());
1049  break;
1053  ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1054  break;
1056  ID.AddInteger((OverloadedOperatorKind)Data);
1057  break;
1062  break;
1063  }
1064 
1065  return ID.ComputeHash();
1066 }
1067 
1068 ModuleFile *
1069 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1070  using namespace llvm::support;
1071 
1072  uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1073  return Reader.getLocalModuleFile(F, ModuleFileID);
1074 }
1075 
1076 std::pair<unsigned, unsigned>
1077 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1078  using namespace llvm::support;
1079 
1080  unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1081  unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1082  return std::make_pair(KeyLen, DataLen);
1083 }
1084 
1086 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1087  using namespace llvm::support;
1088 
1089  auto Kind = (DeclarationName::NameKind)*d++;
1090  uint64_t Data;
1091  switch (Kind) {
1095  Data = (uint64_t)Reader.getLocalIdentifier(
1096  F, endian::readNext<uint32_t, little, unaligned>(d));
1097  break;
1101  Data =
1102  (uint64_t)Reader.getLocalSelector(
1103  F, endian::readNext<uint32_t, little, unaligned>(
1104  d)).getAsOpaquePtr();
1105  break;
1107  Data = *d++; // OverloadedOperatorKind
1108  break;
1113  Data = 0;
1114  break;
1115  }
1116 
1117  return DeclarationNameKey(Kind, Data);
1118 }
1119 
1120 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1121  const unsigned char *d,
1122  unsigned DataLen,
1123  data_type_builder &Val) {
1124  using namespace llvm::support;
1125 
1126  for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1127  uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1128  Val.insert(Reader.getGlobalDeclID(F, LocalID));
1129  }
1130 }
1131 
1132 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1133  BitstreamCursor &Cursor,
1134  uint64_t Offset,
1135  DeclContext *DC) {
1136  assert(Offset != 0);
1137 
1138  SavedStreamPosition SavedPosition(Cursor);
1139  Cursor.JumpToBit(Offset);
1140 
1141  RecordData Record;
1142  StringRef Blob;
1143  unsigned Code = Cursor.ReadCode();
1144  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1145  if (RecCode != DECL_CONTEXT_LEXICAL) {
1146  Error("Expected lexical block");
1147  return true;
1148  }
1149 
1150  assert(!isa<TranslationUnitDecl>(DC) &&
1151  "expected a TU_UPDATE_LEXICAL record for TU");
1152  // If we are handling a C++ class template instantiation, we can see multiple
1153  // lexical updates for the same record. It's important that we select only one
1154  // of them, so that field numbering works properly. Just pick the first one we
1155  // see.
1156  auto &Lex = LexicalDecls[DC];
1157  if (!Lex.first) {
1158  Lex = std::make_pair(
1159  &M, llvm::makeArrayRef(
1160  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1161  Blob.data()),
1162  Blob.size() / 4));
1163  }
1164  DC->setHasExternalLexicalStorage(true);
1165  return false;
1166 }
1167 
1168 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1169  BitstreamCursor &Cursor,
1170  uint64_t Offset,
1171  DeclID ID) {
1172  assert(Offset != 0);
1173 
1174  SavedStreamPosition SavedPosition(Cursor);
1175  Cursor.JumpToBit(Offset);
1176 
1177  RecordData Record;
1178  StringRef Blob;
1179  unsigned Code = Cursor.ReadCode();
1180  unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1181  if (RecCode != DECL_CONTEXT_VISIBLE) {
1182  Error("Expected visible lookup table block");
1183  return true;
1184  }
1185 
1186  // We can't safely determine the primary context yet, so delay attaching the
1187  // lookup table until we're done with recursive deserialization.
1188  auto *Data = (const unsigned char*)Blob.data();
1189  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1190  return false;
1191 }
1192 
1193 void ASTReader::Error(StringRef Msg) const {
1194  Error(diag::err_fe_pch_malformed, Msg);
1195  if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1196  !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1197  Diag(diag::note_module_cache_path)
1198  << PP.getHeaderSearchInfo().getModuleCachePath();
1199  }
1200 }
1201 
1202 void ASTReader::Error(unsigned DiagID,
1203  StringRef Arg1, StringRef Arg2) const {
1204  if (Diags.isDiagnosticInFlight())
1205  Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1206  else
1207  Diag(DiagID) << Arg1 << Arg2;
1208 }
1209 
1210 //===----------------------------------------------------------------------===//
1211 // Source Manager Deserialization
1212 //===----------------------------------------------------------------------===//
1213 
1214 /// \brief Read the line table in the source manager block.
1215 /// \returns true if there was an error.
1216 bool ASTReader::ParseLineTable(ModuleFile &F,
1217  const RecordData &Record) {
1218  unsigned Idx = 0;
1219  LineTableInfo &LineTable = SourceMgr.getLineTable();
1220 
1221  // Parse the file names
1222  std::map<int, int> FileIDs;
1223  FileIDs[-1] = -1; // For unspecified filenames.
1224  for (unsigned I = 0; Record[Idx]; ++I) {
1225  // Extract the file name
1226  auto Filename = ReadPath(F, Record, Idx);
1227  FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1228  }
1229  ++Idx;
1230 
1231  // Parse the line entries
1232  std::vector<LineEntry> Entries;
1233  while (Idx < Record.size()) {
1234  int FID = Record[Idx++];
1235  assert(FID >= 0 && "Serialized line entries for non-local file.");
1236  // Remap FileID from 1-based old view.
1237  FID += F.SLocEntryBaseID - 1;
1238 
1239  // Extract the line entries
1240  unsigned NumEntries = Record[Idx++];
1241  assert(NumEntries && "no line entries for file ID");
1242  Entries.clear();
1243  Entries.reserve(NumEntries);
1244  for (unsigned I = 0; I != NumEntries; ++I) {
1245  unsigned FileOffset = Record[Idx++];
1246  unsigned LineNo = Record[Idx++];
1247  int FilenameID = FileIDs[Record[Idx++]];
1249  = (SrcMgr::CharacteristicKind)Record[Idx++];
1250  unsigned IncludeOffset = Record[Idx++];
1251  Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1252  FileKind, IncludeOffset));
1253  }
1254  LineTable.AddEntry(FileID::get(FID), Entries);
1255  }
1256 
1257  return false;
1258 }
1259 
1260 /// \brief Read a source manager block
1261 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1262  using namespace SrcMgr;
1263 
1264  BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1265 
1266  // Set the source-location entry cursor to the current position in
1267  // the stream. This cursor will be used to read the contents of the
1268  // source manager block initially, and then lazily read
1269  // source-location entries as needed.
1270  SLocEntryCursor = F.Stream;
1271 
1272  // The stream itself is going to skip over the source manager block.
1273  if (F.Stream.SkipBlock()) {
1274  Error("malformed block record in AST file");
1275  return true;
1276  }
1277 
1278  // Enter the source manager block.
1279  if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1280  Error("malformed source manager block record in AST file");
1281  return true;
1282  }
1283 
1284  RecordData Record;
1285  while (true) {
1286  llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1287 
1288  switch (E.Kind) {
1289  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1291  Error("malformed block record in AST file");
1292  return true;
1293  case llvm::BitstreamEntry::EndBlock:
1294  return false;
1295  case llvm::BitstreamEntry::Record:
1296  // The interesting case.
1297  break;
1298  }
1299 
1300  // Read a record.
1301  Record.clear();
1302  StringRef Blob;
1303  switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1304  default: // Default behavior: ignore.
1305  break;
1306 
1307  case SM_SLOC_FILE_ENTRY:
1308  case SM_SLOC_BUFFER_ENTRY:
1310  // Once we hit one of the source location entries, we're done.
1311  return false;
1312  }
1313  }
1314 }
1315 
1316 /// \brief If a header file is not found at the path that we expect it to be
1317 /// and the PCH file was moved from its original location, try to resolve the
1318 /// file by assuming that header+PCH were moved together and the header is in
1319 /// the same place relative to the PCH.
1320 static std::string
1322  const std::string &OriginalDir,
1323  const std::string &CurrDir) {
1324  assert(OriginalDir != CurrDir &&
1325  "No point trying to resolve the file if the PCH dir didn't change");
1326 
1327  using namespace llvm::sys;
1328 
1329  SmallString<128> filePath(Filename);
1330  fs::make_absolute(filePath);
1331  assert(path::is_absolute(OriginalDir));
1332  SmallString<128> currPCHPath(CurrDir);
1333 
1334  path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1335  fileDirE = path::end(path::parent_path(filePath));
1336  path::const_iterator origDirI = path::begin(OriginalDir),
1337  origDirE = path::end(OriginalDir);
1338  // Skip the common path components from filePath and OriginalDir.
1339  while (fileDirI != fileDirE && origDirI != origDirE &&
1340  *fileDirI == *origDirI) {
1341  ++fileDirI;
1342  ++origDirI;
1343  }
1344  for (; origDirI != origDirE; ++origDirI)
1345  path::append(currPCHPath, "..");
1346  path::append(currPCHPath, fileDirI, fileDirE);
1347  path::append(currPCHPath, path::filename(Filename));
1348  return currPCHPath.str();
1349 }
1350 
1352  if (ID == 0)
1353  return false;
1354 
1355  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1356  Error("source location entry ID out-of-range for AST file");
1357  return true;
1358  }
1359 
1360  // Local helper to read the (possibly-compressed) buffer data following the
1361  // entry record.
1362  auto ReadBuffer = [this](
1363  BitstreamCursor &SLocEntryCursor,
1364  StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1365  RecordData Record;
1366  StringRef Blob;
1367  unsigned Code = SLocEntryCursor.ReadCode();
1368  unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1369 
1370  if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1371  if (!llvm::zlib::isAvailable()) {
1372  Error("zlib is not available");
1373  return nullptr;
1374  }
1375  SmallString<0> Uncompressed;
1376  if (llvm::Error E =
1377  llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1378  Error("could not decompress embedded file contents: " +
1379  llvm::toString(std::move(E)));
1380  return nullptr;
1381  }
1382  return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1383  } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1384  return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1385  } else {
1386  Error("AST record has invalid code");
1387  return nullptr;
1388  }
1389  };
1390 
1391  ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1392  F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1393  BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1394  unsigned BaseOffset = F->SLocEntryBaseOffset;
1395 
1396  ++NumSLocEntriesRead;
1397  llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1398  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1399  Error("incorrectly-formatted source location entry in AST file");
1400  return true;
1401  }
1402 
1403  RecordData Record;
1404  StringRef Blob;
1405  switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1406  default:
1407  Error("incorrectly-formatted source location entry in AST file");
1408  return true;
1409 
1410  case SM_SLOC_FILE_ENTRY: {
1411  // We will detect whether a file changed and return 'Failure' for it, but
1412  // we will also try to fail gracefully by setting up the SLocEntry.
1413  unsigned InputID = Record[4];
1414  InputFile IF = getInputFile(*F, InputID);
1415  const FileEntry *File = IF.getFile();
1416  bool OverriddenBuffer = IF.isOverridden();
1417 
1418  // Note that we only check if a File was returned. If it was out-of-date
1419  // we have complained but we will continue creating a FileID to recover
1420  // gracefully.
1421  if (!File)
1422  return true;
1423 
1424  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1425  if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1426  // This is the module's main file.
1427  IncludeLoc = getImportLocation(F);
1428  }
1430  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1431  FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1432  ID, BaseOffset + Record[0]);
1433  SrcMgr::FileInfo &FileInfo =
1434  const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1435  FileInfo.NumCreatedFIDs = Record[5];
1436  if (Record[3])
1437  FileInfo.setHasLineDirectives();
1438 
1439  const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1440  unsigned NumFileDecls = Record[7];
1441  if (NumFileDecls && ContextObj) {
1442  assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1443  FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1444  NumFileDecls));
1445  }
1446 
1447  const SrcMgr::ContentCache *ContentCache
1448  = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1449  if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1450  ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1451  !ContentCache->getRawBuffer()) {
1452  auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1453  if (!Buffer)
1454  return true;
1455  SourceMgr.overrideFileContents(File, std::move(Buffer));
1456  }
1457 
1458  break;
1459  }
1460 
1461  case SM_SLOC_BUFFER_ENTRY: {
1462  const char *Name = Blob.data();
1463  unsigned Offset = Record[0];
1465  FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1466  SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1467  if (IncludeLoc.isInvalid() && F->isModule()) {
1468  IncludeLoc = getImportLocation(F);
1469  }
1470 
1471  auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1472  if (!Buffer)
1473  return true;
1474  SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1475  BaseOffset + Offset, IncludeLoc);
1476  break;
1477  }
1478 
1479  case SM_SLOC_EXPANSION_ENTRY: {
1480  SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1481  SourceMgr.createExpansionLoc(SpellingLoc,
1482  ReadSourceLocation(*F, Record[2]),
1483  ReadSourceLocation(*F, Record[3]),
1484  Record[4],
1485  ID,
1486  BaseOffset + Record[0]);
1487  break;
1488  }
1489  }
1490 
1491  return false;
1492 }
1493 
1494 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1495  if (ID == 0)
1496  return std::make_pair(SourceLocation(), "");
1497 
1498  if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1499  Error("source location entry ID out-of-range for AST file");
1500  return std::make_pair(SourceLocation(), "");
1501  }
1502 
1503  // Find which module file this entry lands in.
1504  ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1505  if (!M->isModule())
1506  return std::make_pair(SourceLocation(), "");
1507 
1508  // FIXME: Can we map this down to a particular submodule? That would be
1509  // ideal.
1510  return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1511 }
1512 
1513 /// \brief Find the location where the module F is imported.
1514 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1515  if (F->ImportLoc.isValid())
1516  return F->ImportLoc;
1517 
1518  // Otherwise we have a PCH. It's considered to be "imported" at the first
1519  // location of its includer.
1520  if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1521  // Main file is the importer.
1522  assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1523  return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1524  }
1525  return F->ImportedBy[0]->FirstLoc;
1526 }
1527 
1528 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1529 /// specified cursor. Read the abbreviations that are at the top of the block
1530 /// and then leave the cursor pointing into the block.
1531 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1532  if (Cursor.EnterSubBlock(BlockID))
1533  return true;
1534 
1535  while (true) {
1536  uint64_t Offset = Cursor.GetCurrentBitNo();
1537  unsigned Code = Cursor.ReadCode();
1538 
1539  // We expect all abbrevs to be at the start of the block.
1540  if (Code != llvm::bitc::DEFINE_ABBREV) {
1541  Cursor.JumpToBit(Offset);
1542  return false;
1543  }
1544  Cursor.ReadAbbrevRecord();
1545  }
1546 }
1547 
1549  unsigned &Idx) {
1550  Token Tok;
1551  Tok.startToken();
1552  Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1553  Tok.setLength(Record[Idx++]);
1554  if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1555  Tok.setIdentifierInfo(II);
1556  Tok.setKind((tok::TokenKind)Record[Idx++]);
1557  Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1558  return Tok;
1559 }
1560 
1562  BitstreamCursor &Stream = F.MacroCursor;
1563 
1564  // Keep track of where we are in the stream, then jump back there
1565  // after reading this macro.
1566  SavedStreamPosition SavedPosition(Stream);
1567 
1568  Stream.JumpToBit(Offset);
1569  RecordData Record;
1571  MacroInfo *Macro = nullptr;
1572 
1573  while (true) {
1574  // Advance to the next record, but if we get to the end of the block, don't
1575  // pop it (removing all the abbreviations from the cursor) since we want to
1576  // be able to reseek within the block and read entries.
1577  unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1578  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1579 
1580  switch (Entry.Kind) {
1581  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1583  Error("malformed block record in AST file");
1584  return Macro;
1585  case llvm::BitstreamEntry::EndBlock:
1586  return Macro;
1587  case llvm::BitstreamEntry::Record:
1588  // The interesting case.
1589  break;
1590  }
1591 
1592  // Read a record.
1593  Record.clear();
1594  PreprocessorRecordTypes RecType =
1595  (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1596  switch (RecType) {
1597  case PP_MODULE_MACRO:
1599  return Macro;
1600 
1601  case PP_MACRO_OBJECT_LIKE:
1602  case PP_MACRO_FUNCTION_LIKE: {
1603  // If we already have a macro, that means that we've hit the end
1604  // of the definition of the macro we were looking for. We're
1605  // done.
1606  if (Macro)
1607  return Macro;
1608 
1609  unsigned NextIndex = 1; // Skip identifier ID.
1610  SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1611  MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1612  MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1613  MI->setIsUsed(Record[NextIndex++]);
1614  MI->setUsedForHeaderGuard(Record[NextIndex++]);
1615 
1616  if (RecType == PP_MACRO_FUNCTION_LIKE) {
1617  // Decode function-like macro info.
1618  bool isC99VarArgs = Record[NextIndex++];
1619  bool isGNUVarArgs = Record[NextIndex++];
1620  bool hasCommaPasting = Record[NextIndex++];
1621  MacroParams.clear();
1622  unsigned NumArgs = Record[NextIndex++];
1623  for (unsigned i = 0; i != NumArgs; ++i)
1624  MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1625 
1626  // Install function-like macro info.
1627  MI->setIsFunctionLike();
1628  if (isC99VarArgs) MI->setIsC99Varargs();
1629  if (isGNUVarArgs) MI->setIsGNUVarargs();
1630  if (hasCommaPasting) MI->setHasCommaPasting();
1631  MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1632  }
1633 
1634  // Remember that we saw this macro last so that we add the tokens that
1635  // form its body to it.
1636  Macro = MI;
1637 
1638  if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1639  Record[NextIndex]) {
1640  // We have a macro definition. Register the association
1642  GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1643  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1644  PreprocessingRecord::PPEntityID PPID =
1645  PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1646  MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1647  PPRec.getPreprocessedEntity(PPID));
1648  if (PPDef)
1649  PPRec.RegisterMacroDefinition(Macro, PPDef);
1650  }
1651 
1652  ++NumMacrosRead;
1653  break;
1654  }
1655 
1656  case PP_TOKEN: {
1657  // If we see a TOKEN before a PP_MACRO_*, then the file is
1658  // erroneous, just pretend we didn't see this.
1659  if (!Macro) break;
1660 
1661  unsigned Idx = 0;
1662  Token Tok = ReadToken(F, Record, Idx);
1663  Macro->AddTokenToBody(Tok);
1664  break;
1665  }
1666  }
1667  }
1668 }
1669 
1672  unsigned LocalID) const {
1673  if (!M.ModuleOffsetMap.empty())
1674  ReadModuleOffsetMap(M);
1675 
1678  assert(I != M.PreprocessedEntityRemap.end()
1679  && "Invalid index into preprocessed entity index remap");
1680 
1681  return LocalID + I->second;
1682 }
1683 
1685  return llvm::hash_combine(ikey.Size, ikey.ModTime);
1686 }
1687 
1689 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1690  internal_key_type ikey = {FE->getSize(),
1691  M.HasTimestamps ? FE->getModificationTime() : 0,
1692  FE->getName(), /*Imported*/ false};
1693  return ikey;
1694 }
1695 
1696 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1697  if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1698  return false;
1699 
1700  if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1701  return true;
1702 
1703  // Determine whether the actual files are equivalent.
1704  FileManager &FileMgr = Reader.getFileManager();
1705  auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1706  if (!Key.Imported)
1707  return FileMgr.getFile(Key.Filename);
1708 
1709  std::string Resolved = Key.Filename;
1710  Reader.ResolveImportedPath(M, Resolved);
1711  return FileMgr.getFile(Resolved);
1712  };
1713 
1714  const FileEntry *FEA = GetFile(a);
1715  const FileEntry *FEB = GetFile(b);
1716  return FEA && FEA == FEB;
1717 }
1718 
1719 std::pair<unsigned, unsigned>
1720 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1721  using namespace llvm::support;
1722 
1723  unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1724  unsigned DataLen = (unsigned) *d++;
1725  return std::make_pair(KeyLen, DataLen);
1726 }
1727 
1729 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1730  using namespace llvm::support;
1731 
1732  internal_key_type ikey;
1733  ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1734  ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1735  ikey.Filename = (const char *)d;
1736  ikey.Imported = true;
1737  return ikey;
1738 }
1739 
1741 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1742  unsigned DataLen) {
1743  using namespace llvm::support;
1744 
1745  const unsigned char *End = d + DataLen;
1746  HeaderFileInfo HFI;
1747  unsigned Flags = *d++;
1748  // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1749  HFI.isImport |= (Flags >> 5) & 0x01;
1750  HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1751  HFI.DirInfo = (Flags >> 1) & 0x07;
1752  HFI.IndexHeaderMapHeader = Flags & 0x01;
1753  // FIXME: Find a better way to handle this. Maybe just store a
1754  // "has been included" flag?
1755  HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1756  HFI.NumIncludes);
1757  HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1758  M, endian::readNext<uint32_t, little, unaligned>(d));
1759  if (unsigned FrameworkOffset =
1760  endian::readNext<uint32_t, little, unaligned>(d)) {
1761  // The framework offset is 1 greater than the actual offset,
1762  // since 0 is used as an indicator for "no framework name".
1763  StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1764  HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1765  }
1766 
1767  assert((End - d) % 4 == 0 &&
1768  "Wrong data length in HeaderFileInfo deserialization");
1769  while (d != End) {
1770  uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1771  auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1772  LocalSMID >>= 2;
1773 
1774  // This header is part of a module. Associate it with the module to enable
1775  // implicit module import.
1776  SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1777  Module *Mod = Reader.getSubmodule(GlobalSMID);
1778  FileManager &FileMgr = Reader.getFileManager();
1779  ModuleMap &ModMap =
1780  Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1781 
1782  std::string Filename = key.Filename;
1783  if (key.Imported)
1784  Reader.ResolveImportedPath(M, Filename);
1785  // FIXME: This is not always the right filename-as-written, but we're not
1786  // going to use this information to rebuild the module, so it doesn't make
1787  // a lot of difference.
1788  Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1789  ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1790  HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1791  }
1792 
1793  // This HeaderFileInfo was externally loaded.
1794  HFI.External = true;
1795  HFI.IsValid = true;
1796  return HFI;
1797 }
1798 
1800  ModuleFile *M,
1801  uint64_t MacroDirectivesOffset) {
1802  assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1803  PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1804 }
1805 
1807  // Note that we are loading defined macros.
1808  Deserializing Macros(this);
1809 
1810  for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1811  BitstreamCursor &MacroCursor = I.MacroCursor;
1812 
1813  // If there was no preprocessor block, skip this file.
1814  if (MacroCursor.getBitcodeBytes().empty())
1815  continue;
1816 
1817  BitstreamCursor Cursor = MacroCursor;
1818  Cursor.JumpToBit(I.MacroStartOffset);
1819 
1820  RecordData Record;
1821  while (true) {
1822  llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1823 
1824  switch (E.Kind) {
1825  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1827  Error("malformed block record in AST file");
1828  return;
1829  case llvm::BitstreamEntry::EndBlock:
1830  goto NextCursor;
1831 
1832  case llvm::BitstreamEntry::Record:
1833  Record.clear();
1834  switch (Cursor.readRecord(E.ID, Record)) {
1835  default: // Default behavior: ignore.
1836  break;
1837 
1838  case PP_MACRO_OBJECT_LIKE:
1839  case PP_MACRO_FUNCTION_LIKE: {
1840  IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1841  if (II->isOutOfDate())
1842  updateOutOfDateIdentifier(*II);
1843  break;
1844  }
1845 
1846  case PP_TOKEN:
1847  // Ignore tokens.
1848  break;
1849  }
1850  break;
1851  }
1852  }
1853  NextCursor: ;
1854  }
1855 }
1856 
1857 namespace {
1858 
1859  /// \brief Visitor class used to look up identifirs in an AST file.
1860  class IdentifierLookupVisitor {
1861  StringRef Name;
1862  unsigned NameHash;
1863  unsigned PriorGeneration;
1864  unsigned &NumIdentifierLookups;
1865  unsigned &NumIdentifierLookupHits;
1866  IdentifierInfo *Found = nullptr;
1867 
1868  public:
1869  IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1870  unsigned &NumIdentifierLookups,
1871  unsigned &NumIdentifierLookupHits)
1872  : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1873  PriorGeneration(PriorGeneration),
1874  NumIdentifierLookups(NumIdentifierLookups),
1875  NumIdentifierLookupHits(NumIdentifierLookupHits) {}
1876 
1877  bool operator()(ModuleFile &M) {
1878  // If we've already searched this module file, skip it now.
1879  if (M.Generation <= PriorGeneration)
1880  return true;
1881 
1882  ASTIdentifierLookupTable *IdTable
1884  if (!IdTable)
1885  return false;
1886 
1887  ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1888  Found);
1889  ++NumIdentifierLookups;
1890  ASTIdentifierLookupTable::iterator Pos =
1891  IdTable->find_hashed(Name, NameHash, &Trait);
1892  if (Pos == IdTable->end())
1893  return false;
1894 
1895  // Dereferencing the iterator has the effect of building the
1896  // IdentifierInfo node and populating it with the various
1897  // declarations it needs.
1898  ++NumIdentifierLookupHits;
1899  Found = *Pos;
1900  return true;
1901  }
1902 
1903  // \brief Retrieve the identifier info found within the module
1904  // files.
1905  IdentifierInfo *getIdentifierInfo() const { return Found; }
1906  };
1907 
1908 } // namespace
1909 
1911  // Note that we are loading an identifier.
1912  Deserializing AnIdentifier(this);
1913 
1914  unsigned PriorGeneration = 0;
1915  if (getContext().getLangOpts().Modules)
1916  PriorGeneration = IdentifierGeneration[&II];
1917 
1918  // If there is a global index, look there first to determine which modules
1919  // provably do not have any results for this identifier.
1921  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1922  if (!loadGlobalIndex()) {
1923  if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1924  HitsPtr = &Hits;
1925  }
1926  }
1927 
1928  IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1929  NumIdentifierLookups,
1930  NumIdentifierLookupHits);
1931  ModuleMgr.visit(Visitor, HitsPtr);
1932  markIdentifierUpToDate(&II);
1933 }
1934 
1936  if (!II)
1937  return;
1938 
1939  II->setOutOfDate(false);
1940 
1941  // Update the generation for this identifier.
1942  if (getContext().getLangOpts().Modules)
1943  IdentifierGeneration[II] = getGeneration();
1944 }
1945 
1947  const PendingMacroInfo &PMInfo) {
1948  ModuleFile &M = *PMInfo.M;
1949 
1950  BitstreamCursor &Cursor = M.MacroCursor;
1951  SavedStreamPosition SavedPosition(Cursor);
1952  Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1953 
1954  struct ModuleMacroRecord {
1955  SubmoduleID SubModID;
1956  MacroInfo *MI;
1957  SmallVector<SubmoduleID, 8> Overrides;
1958  };
1960 
1961  // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1962  // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1963  // macro histroy.
1964  RecordData Record;
1965  while (true) {
1966  llvm::BitstreamEntry Entry =
1967  Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1968  if (Entry.Kind != llvm::BitstreamEntry::Record) {
1969  Error("malformed block record in AST file");
1970  return;
1971  }
1972 
1973  Record.clear();
1974  switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1976  break;
1977 
1978  case PP_MODULE_MACRO: {
1979  ModuleMacros.push_back(ModuleMacroRecord());
1980  auto &Info = ModuleMacros.back();
1981  Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1982  Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1983  for (int I = 2, N = Record.size(); I != N; ++I)
1984  Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1985  continue;
1986  }
1987 
1988  default:
1989  Error("malformed block record in AST file");
1990  return;
1991  }
1992 
1993  // We found the macro directive history; that's the last record
1994  // for this macro.
1995  break;
1996  }
1997 
1998  // Module macros are listed in reverse dependency order.
1999  {
2000  std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2002  for (auto &MMR : ModuleMacros) {
2003  Overrides.clear();
2004  for (unsigned ModID : MMR.Overrides) {
2005  Module *Mod = getSubmodule(ModID);
2006  auto *Macro = PP.getModuleMacro(Mod, II);
2007  assert(Macro && "missing definition for overridden macro");
2008  Overrides.push_back(Macro);
2009  }
2010 
2011  bool Inserted = false;
2012  Module *Owner = getSubmodule(MMR.SubModID);
2013  PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2014  }
2015  }
2016 
2017  // Don't read the directive history for a module; we don't have anywhere
2018  // to put it.
2019  if (M.isModule())
2020  return;
2021 
2022  // Deserialize the macro directives history in reverse source-order.
2023  MacroDirective *Latest = nullptr, *Earliest = nullptr;
2024  unsigned Idx = 0, N = Record.size();
2025  while (Idx < N) {
2026  MacroDirective *MD = nullptr;
2027  SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2028  MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2029  switch (K) {
2031  MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2032  MD = PP.AllocateDefMacroDirective(MI, Loc);
2033  break;
2034  }
2036  MD = PP.AllocateUndefMacroDirective(Loc);
2037  break;
2039  bool isPublic = Record[Idx++];
2040  MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2041  break;
2042  }
2043 
2044  if (!Latest)
2045  Latest = MD;
2046  if (Earliest)
2047  Earliest->setPrevious(MD);
2048  Earliest = MD;
2049  }
2050 
2051  if (Latest)
2052  PP.setLoadedMacroDirective(II, Earliest, Latest);
2053 }
2054 
2055 ASTReader::InputFileInfo
2056 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2057  // Go find this input file.
2058  BitstreamCursor &Cursor = F.InputFilesCursor;
2059  SavedStreamPosition SavedPosition(Cursor);
2060  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2061 
2062  unsigned Code = Cursor.ReadCode();
2063  RecordData Record;
2064  StringRef Blob;
2065 
2066  unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2067  assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
2068  "invalid record type for input file");
2069  (void)Result;
2070 
2071  assert(Record[0] == ID && "Bogus stored ID or offset");
2072  InputFileInfo R;
2073  R.StoredSize = static_cast<off_t>(Record[1]);
2074  R.StoredTime = static_cast<time_t>(Record[2]);
2075  R.Overridden = static_cast<bool>(Record[3]);
2076  R.Transient = static_cast<bool>(Record[4]);
2077  R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2078  R.Filename = Blob;
2079  ResolveImportedPath(F, R.Filename);
2080  return R;
2081 }
2082 
2083 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2084 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2085  // If this ID is bogus, just return an empty input file.
2086  if (ID == 0 || ID > F.InputFilesLoaded.size())
2087  return InputFile();
2088 
2089  // If we've already loaded this input file, return it.
2090  if (F.InputFilesLoaded[ID-1].getFile())
2091  return F.InputFilesLoaded[ID-1];
2092 
2093  if (F.InputFilesLoaded[ID-1].isNotFound())
2094  return InputFile();
2095 
2096  // Go find this input file.
2097  BitstreamCursor &Cursor = F.InputFilesCursor;
2098  SavedStreamPosition SavedPosition(Cursor);
2099  Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2100 
2101  InputFileInfo FI = readInputFileInfo(F, ID);
2102  off_t StoredSize = FI.StoredSize;
2103  time_t StoredTime = FI.StoredTime;
2104  bool Overridden = FI.Overridden;
2105  bool Transient = FI.Transient;
2106  StringRef Filename = FI.Filename;
2107 
2108  const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2109  // If we didn't find the file, resolve it relative to the
2110  // original directory from which this AST file was created.
2111  if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2112  F.OriginalDir != F.BaseDirectory) {
2113  std::string Resolved = resolveFileRelativeToOriginalDir(
2114  Filename, F.OriginalDir, F.BaseDirectory);
2115  if (!Resolved.empty())
2116  File = FileMgr.getFile(Resolved);
2117  }
2118 
2119  // For an overridden file, create a virtual file with the stored
2120  // size/timestamp.
2121  if ((Overridden || Transient) && File == nullptr)
2122  File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2123 
2124  if (File == nullptr) {
2125  if (Complain) {
2126  std::string ErrorStr = "could not find file '";
2127  ErrorStr += Filename;
2128  ErrorStr += "' referenced by AST file '";
2129  ErrorStr += F.FileName;
2130  ErrorStr += "'";
2131  Error(ErrorStr);
2132  }
2133  // Record that we didn't find the file.
2135  return InputFile();
2136  }
2137 
2138  // Check if there was a request to override the contents of the file
2139  // that was part of the precompiled header. Overridding such a file
2140  // can lead to problems when lexing using the source locations from the
2141  // PCH.
2142  SourceManager &SM = getSourceManager();
2143  // FIXME: Reject if the overrides are different.
2144  if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2145  if (Complain)
2146  Error(diag::err_fe_pch_file_overridden, Filename);
2147  // After emitting the diagnostic, recover by disabling the override so
2148  // that the original file will be used.
2149  //
2150  // FIXME: This recovery is just as broken as the original state; there may
2151  // be another precompiled module that's using the overridden contents, or
2152  // we might be half way through parsing it. Instead, we should treat the
2153  // overridden contents as belonging to a separate FileEntry.
2154  SM.disableFileContentsOverride(File);
2155  // The FileEntry is a virtual file entry with the size of the contents
2156  // that would override the original contents. Set it to the original's
2157  // size/time.
2158  FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2159  StoredSize, StoredTime);
2160  }
2161 
2162  bool IsOutOfDate = false;
2163 
2164  // For an overridden file, there is nothing to validate.
2165  if (!Overridden && //
2166  (StoredSize != File->getSize() ||
2167  (StoredTime && StoredTime != File->getModificationTime() &&
2168  !DisableValidation)
2169  )) {
2170  if (Complain) {
2171  // Build a list of the PCH imports that got us here (in reverse).
2172  SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2173  while (!ImportStack.back()->ImportedBy.empty())
2174  ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2175 
2176  // The top-level PCH is stale.
2177  StringRef TopLevelPCHName(ImportStack.back()->FileName);
2178  unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2179  if (DiagnosticKind == 0)
2180  Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2181  else if (DiagnosticKind == 1)
2182  Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2183  else
2184  Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2185 
2186  // Print the import stack.
2187  if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2188  Diag(diag::note_pch_required_by)
2189  << Filename << ImportStack[0]->FileName;
2190  for (unsigned I = 1; I < ImportStack.size(); ++I)
2191  Diag(diag::note_pch_required_by)
2192  << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2193  }
2194 
2195  if (!Diags.isDiagnosticInFlight())
2196  Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2197  }
2198 
2199  IsOutOfDate = true;
2200  }
2201  // FIXME: If the file is overridden and we've already opened it,
2202  // issue an error (or split it into a separate FileEntry).
2203 
2204  InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2205 
2206  // Note that we've loaded this input file.
2207  F.InputFilesLoaded[ID-1] = IF;
2208  return IF;
2209 }
2210 
2211 /// \brief If we are loading a relocatable PCH or module file, and the filename
2212 /// is not an absolute path, add the system or module root to the beginning of
2213 /// the file name.
2215  // Resolve relative to the base directory, if we have one.
2216  if (!M.BaseDirectory.empty())
2217  return ResolveImportedPath(Filename, M.BaseDirectory);
2218 }
2219 
2220 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2221  if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2222  return;
2223 
2224  SmallString<128> Buffer;
2225  llvm::sys::path::append(Buffer, Prefix, Filename);
2226  Filename.assign(Buffer.begin(), Buffer.end());
2227 }
2228 
2229 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2230  switch (ARR) {
2231  case ASTReader::Failure: return true;
2232  case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2233  case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2236  return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2237  case ASTReader::HadErrors: return true;
2238  case ASTReader::Success: return false;
2239  }
2240 
2241  llvm_unreachable("unknown ASTReadResult");
2242 }
2243 
2244 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2245  BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2246  bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2247  std::string &SuggestedPredefines) {
2248  if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2249  return Failure;
2250 
2251  // Read all of the records in the options block.
2252  RecordData Record;
2253  ASTReadResult Result = Success;
2254  while (true) {
2255  llvm::BitstreamEntry Entry = Stream.advance();
2256 
2257  switch (Entry.Kind) {
2259  case llvm::BitstreamEntry::SubBlock:
2260  return Failure;
2261 
2262  case llvm::BitstreamEntry::EndBlock:
2263  return Result;
2264 
2265  case llvm::BitstreamEntry::Record:
2266  // The interesting case.
2267  break;
2268  }
2269 
2270  // Read and process a record.
2271  Record.clear();
2272  switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2273  case LANGUAGE_OPTIONS: {
2274  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2275  if (ParseLanguageOptions(Record, Complain, Listener,
2276  AllowCompatibleConfigurationMismatch))
2277  Result = ConfigurationMismatch;
2278  break;
2279  }
2280 
2281  case TARGET_OPTIONS: {
2282  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2283  if (ParseTargetOptions(Record, Complain, Listener,
2284  AllowCompatibleConfigurationMismatch))
2285  Result = ConfigurationMismatch;
2286  break;
2287  }
2288 
2289  case FILE_SYSTEM_OPTIONS: {
2290  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2291  if (!AllowCompatibleConfigurationMismatch &&
2292  ParseFileSystemOptions(Record, Complain, Listener))
2293  Result = ConfigurationMismatch;
2294  break;
2295  }
2296 
2297  case HEADER_SEARCH_OPTIONS: {
2298  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2299  if (!AllowCompatibleConfigurationMismatch &&
2300  ParseHeaderSearchOptions(Record, Complain, Listener))
2301  Result = ConfigurationMismatch;
2302  break;
2303  }
2304 
2305  case PREPROCESSOR_OPTIONS:
2306  bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2307  if (!AllowCompatibleConfigurationMismatch &&
2308  ParsePreprocessorOptions(Record, Complain, Listener,
2309  SuggestedPredefines))
2310  Result = ConfigurationMismatch;
2311  break;
2312  }
2313  }
2314 }
2315 
2317 ASTReader::ReadControlBlock(ModuleFile &F,
2319  const ModuleFile *ImportedBy,
2320  unsigned ClientLoadCapabilities) {
2321  BitstreamCursor &Stream = F.Stream;
2322  ASTReadResult Result = Success;
2323 
2324  if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2325  Error("malformed block record in AST file");
2326  return Failure;
2327  }
2328 
2329  // Lambda to read the unhashed control block the first time it's called.
2330  //
2331  // For PCM files, the unhashed control block cannot be read until after the
2332  // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2333  // need to look ahead before reading the IMPORTS record. For consistency,
2334  // this block is always read somehow (see BitstreamEntry::EndBlock).
2335  bool HasReadUnhashedControlBlock = false;
2336  auto readUnhashedControlBlockOnce = [&]() {
2337  if (!HasReadUnhashedControlBlock) {
2338  HasReadUnhashedControlBlock = true;
2339  if (ASTReadResult Result =
2340  readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2341  return Result;
2342  }
2343  return Success;
2344  };
2345 
2346  // Read all of the records and blocks in the control block.
2347  RecordData Record;
2348  unsigned NumInputs = 0;
2349  unsigned NumUserInputs = 0;
2350  while (true) {
2351  llvm::BitstreamEntry Entry = Stream.advance();
2352 
2353  switch (Entry.Kind) {
2355  Error("malformed block record in AST file");
2356  return Failure;
2357  case llvm::BitstreamEntry::EndBlock: {
2358  // Validate the module before returning. This call catches an AST with
2359  // no module name and no imports.
2360  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2361  return Result;
2362 
2363  // Validate input files.
2364  const HeaderSearchOptions &HSOpts =
2365  PP.getHeaderSearchInfo().getHeaderSearchOpts();
2366 
2367  // All user input files reside at the index range [0, NumUserInputs), and
2368  // system input files reside at [NumUserInputs, NumInputs). For explicitly
2369  // loaded module files, ignore missing inputs.
2370  if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2371  F.Kind != MK_PrebuiltModule) {
2372  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2373 
2374  // If we are reading a module, we will create a verification timestamp,
2375  // so we verify all input files. Otherwise, verify only user input
2376  // files.
2377 
2378  unsigned N = NumUserInputs;
2379  if (ValidateSystemInputs ||
2382  F.Kind == MK_ImplicitModule))
2383  N = NumInputs;
2384 
2385  for (unsigned I = 0; I < N; ++I) {
2386  InputFile IF = getInputFile(F, I+1, Complain);
2387  if (!IF.getFile() || IF.isOutOfDate())
2388  return OutOfDate;
2389  }
2390  }
2391 
2392  if (Listener)
2393  Listener->visitModuleFile(F.FileName, F.Kind);
2394 
2395  if (Listener && Listener->needsInputFileVisitation()) {
2396  unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2397  : NumUserInputs;
2398  for (unsigned I = 0; I < N; ++I) {
2399  bool IsSystem = I >= NumUserInputs;
2400  InputFileInfo FI = readInputFileInfo(F, I+1);
2401  Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2402  F.Kind == MK_ExplicitModule ||
2403  F.Kind == MK_PrebuiltModule);
2404  }
2405  }
2406 
2407  return Result;
2408  }
2409 
2410  case llvm::BitstreamEntry::SubBlock:
2411  switch (Entry.ID) {
2412  case INPUT_FILES_BLOCK_ID:
2413  F.InputFilesCursor = Stream;
2414  if (Stream.SkipBlock() || // Skip with the main cursor
2415  // Read the abbreviations
2416  ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2417  Error("malformed block record in AST file");
2418  return Failure;
2419  }
2420  continue;
2421 
2422  case OPTIONS_BLOCK_ID:
2423  // If we're reading the first module for this group, check its options
2424  // are compatible with ours. For modules it imports, no further checking
2425  // is required, because we checked them when we built it.
2426  if (Listener && !ImportedBy) {
2427  // Should we allow the configuration of the module file to differ from
2428  // the configuration of the current translation unit in a compatible
2429  // way?
2430  //
2431  // FIXME: Allow this for files explicitly specified with -include-pch.
2432  bool AllowCompatibleConfigurationMismatch =
2434 
2435  Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2436  AllowCompatibleConfigurationMismatch,
2437  *Listener, SuggestedPredefines);
2438  if (Result == Failure) {
2439  Error("malformed block record in AST file");
2440  return Result;
2441  }
2442 
2443  if (DisableValidation ||
2444  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2445  Result = Success;
2446 
2447  // If we can't load the module, exit early since we likely
2448  // will rebuild the module anyway. The stream may be in the
2449  // middle of a block.
2450  if (Result != Success)
2451  return Result;
2452  } else if (Stream.SkipBlock()) {
2453  Error("malformed block record in AST file");
2454  return Failure;
2455  }
2456  continue;
2457 
2458  default:
2459  if (Stream.SkipBlock()) {
2460  Error("malformed block record in AST file");
2461  return Failure;
2462  }
2463  continue;
2464  }
2465 
2466  case llvm::BitstreamEntry::Record:
2467  // The interesting case.
2468  break;
2469  }
2470 
2471  // Read and process a record.
2472  Record.clear();
2473  StringRef Blob;
2474  switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2475  case METADATA: {
2476  if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2477  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2478  Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2479  : diag::err_pch_version_too_new);
2480  return VersionMismatch;
2481  }
2482 
2483  bool hasErrors = Record[6];
2484  if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2485  Diag(diag::err_pch_with_compiler_errors);
2486  return HadErrors;
2487  }
2488  if (hasErrors) {
2489  Diags.ErrorOccurred = true;
2490  Diags.UncompilableErrorOccurred = true;
2491  Diags.UnrecoverableErrorOccurred = true;
2492  }
2493 
2494  F.RelocatablePCH = Record[4];
2495  // Relative paths in a relocatable PCH are relative to our sysroot.
2496  if (F.RelocatablePCH)
2497  F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2498 
2499  F.HasTimestamps = Record[5];
2500 
2501  const std::string &CurBranch = getClangFullRepositoryVersion();
2502  StringRef ASTBranch = Blob;
2503  if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2504  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2505  Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2506  return VersionMismatch;
2507  }
2508  break;
2509  }
2510 
2511  case IMPORTS: {
2512  // Validate the AST before processing any imports (otherwise, untangling
2513  // them can be error-prone and expensive). A module will have a name and
2514  // will already have been validated, but this catches the PCH case.
2515  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2516  return Result;
2517 
2518  // Load each of the imported PCH files.
2519  unsigned Idx = 0, N = Record.size();
2520  while (Idx < N) {
2521  // Read information about the AST file.
2522  ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2523  // The import location will be the local one for now; we will adjust
2524  // all import locations of module imports after the global source
2525  // location info are setup, in ReadAST.
2526  SourceLocation ImportLoc =
2527  ReadUntranslatedSourceLocation(Record[Idx++]);
2528  off_t StoredSize = (off_t)Record[Idx++];
2529  time_t StoredModTime = (time_t)Record[Idx++];
2530  ASTFileSignature StoredSignature = {
2531  {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2532  (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2533  (uint32_t)Record[Idx++]}}};
2534 
2535  std::string ImportedName = ReadString(Record, Idx);
2536  std::string ImportedFile;
2537 
2538  // For prebuilt and explicit modules first consult the file map for
2539  // an override. Note that here we don't search prebuilt module
2540  // directories, only the explicit name to file mappings. Also, we will
2541  // still verify the size/signature making sure it is essentially the
2542  // same file but perhaps in a different location.
2543  if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2544  ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2545  ImportedName, /*FileMapOnly*/ true);
2546 
2547  if (ImportedFile.empty())
2548  ImportedFile = ReadPath(F, Record, Idx);
2549  else
2550  SkipPath(Record, Idx);
2551 
2552  // If our client can't cope with us being out of date, we can't cope with
2553  // our dependency being missing.
2554  unsigned Capabilities = ClientLoadCapabilities;
2555  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2556  Capabilities &= ~ARR_Missing;
2557 
2558  // Load the AST file.
2559  auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2560  Loaded, StoredSize, StoredModTime,
2561  StoredSignature, Capabilities);
2562 
2563  // If we diagnosed a problem, produce a backtrace.
2564  if (isDiagnosedResult(Result, Capabilities))
2565  Diag(diag::note_module_file_imported_by)
2566  << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2567 
2568  switch (Result) {
2569  case Failure: return Failure;
2570  // If we have to ignore the dependency, we'll have to ignore this too.
2571  case Missing:
2572  case OutOfDate: return OutOfDate;
2573  case VersionMismatch: return VersionMismatch;
2574  case ConfigurationMismatch: return ConfigurationMismatch;
2575  case HadErrors: return HadErrors;
2576  case Success: break;
2577  }
2578  }
2579  break;
2580  }
2581 
2582  case ORIGINAL_FILE:
2583  F.OriginalSourceFileID = FileID::get(Record[0]);
2586  ResolveImportedPath(F, F.OriginalSourceFileName);
2587  break;
2588 
2589  case ORIGINAL_FILE_ID:
2590  F.OriginalSourceFileID = FileID::get(Record[0]);
2591  break;
2592 
2593  case ORIGINAL_PCH_DIR:
2594  F.OriginalDir = Blob;
2595  break;
2596 
2597  case MODULE_NAME:
2598  F.ModuleName = Blob;
2599  if (Listener)
2600  Listener->ReadModuleName(F.ModuleName);
2601 
2602  // Validate the AST as soon as we have a name so we can exit early on
2603  // failure.
2604  if (ASTReadResult Result = readUnhashedControlBlockOnce())
2605  return Result;
2606 
2607  break;
2608 
2609  case MODULE_DIRECTORY: {
2610  assert(!F.ModuleName.empty() &&
2611  "MODULE_DIRECTORY found before MODULE_NAME");
2612  // If we've already loaded a module map file covering this module, we may
2613  // have a better path for it (relative to the current build).
2614  Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
2615  if (M && M->Directory) {
2616  // If we're implicitly loading a module, the base directory can't
2617  // change between the build and use.
2618  if (F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2619  const DirectoryEntry *BuildDir =
2620  PP.getFileManager().getDirectory(Blob);
2621  if (!BuildDir || BuildDir != M->Directory) {
2622  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2623  Diag(diag::err_imported_module_relocated)
2624  << F.ModuleName << Blob << M->Directory->getName();
2625  return OutOfDate;
2626  }
2627  }
2628  F.BaseDirectory = M->Directory->getName();
2629  } else {
2630  F.BaseDirectory = Blob;
2631  }
2632  break;
2633  }
2634 
2635  case MODULE_MAP_FILE:
2636  if (ASTReadResult Result =
2637  ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2638  return Result;
2639  break;
2640 
2641  case INPUT_FILE_OFFSETS:
2642  NumInputs = Record[0];
2643  NumUserInputs = Record[1];
2644  F.InputFileOffsets =
2645  (const llvm::support::unaligned_uint64_t *)Blob.data();
2646  F.InputFilesLoaded.resize(NumInputs);
2647  F.NumUserInputFiles = NumUserInputs;
2648  break;
2649  }
2650  }
2651 }
2652 
2654 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2655  BitstreamCursor &Stream = F.Stream;
2656 
2657  if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2658  Error("malformed block record in AST file");
2659  return Failure;
2660  }
2661 
2662  // Read all of the records and blocks for the AST file.
2663  RecordData Record;
2664  while (true) {
2665  llvm::BitstreamEntry Entry = Stream.advance();
2666 
2667  switch (Entry.Kind) {
2669  Error("error at end of module block in AST file");
2670  return Failure;
2671  case llvm::BitstreamEntry::EndBlock:
2672  // Outside of C++, we do not store a lookup map for the translation unit.
2673  // Instead, mark it as needing a lookup map to be built if this module
2674  // contains any declarations lexically within it (which it always does!).
2675  // This usually has no cost, since we very rarely need the lookup map for
2676  // the translation unit outside C++.
2677  if (ASTContext *Ctx = ContextObj) {
2678  DeclContext *DC = Ctx->getTranslationUnitDecl();
2679  if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2681  }
2682 
2683  return Success;
2684  case llvm::BitstreamEntry::SubBlock:
2685  switch (Entry.ID) {
2686  case DECLTYPES_BLOCK_ID:
2687  // We lazily load the decls block, but we want to set up the
2688  // DeclsCursor cursor to point into it. Clone our current bitcode
2689  // cursor to it, enter the block and read the abbrevs in that block.
2690  // With the main cursor, we just skip over it.
2691  F.DeclsCursor = Stream;
2692  if (Stream.SkipBlock() || // Skip with the main cursor.
2693  // Read the abbrevs.
2694  ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2695  Error("malformed block record in AST file");
2696  return Failure;
2697  }
2698  break;
2699 
2700  case PREPROCESSOR_BLOCK_ID:
2701  F.MacroCursor = Stream;
2702  if (!PP.getExternalSource())
2703  PP.setExternalSource(this);
2704 
2705  if (Stream.SkipBlock() ||
2706  ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2707  Error("malformed block record in AST file");
2708  return Failure;
2709  }
2710  F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2711  break;
2712 
2714  F.PreprocessorDetailCursor = Stream;
2715  if (Stream.SkipBlock() ||
2716  ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2718  Error("malformed preprocessor detail record in AST file");
2719  return Failure;
2720  }
2722  = F.PreprocessorDetailCursor.GetCurrentBitNo();
2723 
2724  if (!PP.getPreprocessingRecord())
2725  PP.createPreprocessingRecord();
2726  if (!PP.getPreprocessingRecord()->getExternalSource())
2727  PP.getPreprocessingRecord()->SetExternalSource(*this);
2728  break;
2729 
2731  if (ReadSourceManagerBlock(F))
2732  return Failure;
2733  break;
2734 
2735  case SUBMODULE_BLOCK_ID:
2736  if (ASTReadResult Result =
2737  ReadSubmoduleBlock(F, ClientLoadCapabilities))
2738  return Result;
2739  break;
2740 
2741  case COMMENTS_BLOCK_ID: {
2742  BitstreamCursor C = Stream;
2743  if (Stream.SkipBlock() ||
2744  ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2745  Error("malformed comments block in AST file");
2746  return Failure;
2747  }
2748  CommentsCursors.push_back(std::make_pair(C, &F));
2749  break;
2750  }
2751 
2752  default:
2753  if (Stream.SkipBlock()) {
2754  Error("malformed block record in AST file");
2755  return Failure;
2756  }
2757  break;
2758  }
2759  continue;
2760 
2761  case llvm::BitstreamEntry::Record:
2762  // The interesting case.
2763  break;
2764  }
2765 
2766  // Read and process a record.
2767  Record.clear();
2768  StringRef Blob;
2769  auto RecordType =
2770  (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2771 
2772  // If we're not loading an AST context, we don't care about most records.
2773  if (!ContextObj) {
2774  switch (RecordType) {
2775  case IDENTIFIER_TABLE:
2776  case IDENTIFIER_OFFSET:
2778  case STATISTICS:
2779  case PP_CONDITIONAL_STACK:
2780  case PP_COUNTER_VALUE:
2782  case MODULE_OFFSET_MAP:
2785  case PPD_ENTITIES_OFFSETS:
2786  case HEADER_SEARCH_TABLE:
2787  case IMPORTED_MODULES:
2788  case MACRO_OFFSET:
2789  break;
2790  default:
2791  continue;
2792  }
2793  }
2794 
2795  switch (RecordType) {
2796  default: // Default behavior: ignore.
2797  break;
2798 
2799  case TYPE_OFFSET: {
2800  if (F.LocalNumTypes != 0) {
2801  Error("duplicate TYPE_OFFSET record in AST file");
2802  return Failure;
2803  }
2804  F.TypeOffsets = (const uint32_t *)Blob.data();
2805  F.LocalNumTypes = Record[0];
2806  unsigned LocalBaseTypeIndex = Record[1];
2807  F.BaseTypeIndex = getTotalNumTypes();
2808 
2809  if (F.LocalNumTypes > 0) {
2810  // Introduce the global -> local mapping for types within this module.
2811  GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2812 
2813  // Introduce the local -> global mapping for types within this module.
2815  std::make_pair(LocalBaseTypeIndex,
2816  F.BaseTypeIndex - LocalBaseTypeIndex));
2817 
2818  TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2819  }
2820  break;
2821  }
2822 
2823  case DECL_OFFSET: {
2824  if (F.LocalNumDecls != 0) {
2825  Error("duplicate DECL_OFFSET record in AST file");
2826  return Failure;
2827  }
2828  F.DeclOffsets = (const DeclOffset *)Blob.data();
2829  F.LocalNumDecls = Record[0];
2830  unsigned LocalBaseDeclID = Record[1];
2831  F.BaseDeclID = getTotalNumDecls();
2832 
2833  if (F.LocalNumDecls > 0) {
2834  // Introduce the global -> local mapping for declarations within this
2835  // module.
2836  GlobalDeclMap.insert(
2837  std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2838 
2839  // Introduce the local -> global mapping for declarations within this
2840  // module.
2842  std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2843 
2844  // Introduce the global -> local mapping for declarations within this
2845  // module.
2846  F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2847 
2848  DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2849  }
2850  break;
2851  }
2852 
2853  case TU_UPDATE_LEXICAL: {
2854  DeclContext *TU = ContextObj->getTranslationUnitDecl();
2855  LexicalContents Contents(
2856  reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2857  Blob.data()),
2858  static_cast<unsigned int>(Blob.size() / 4));
2859  TULexicalDecls.push_back(std::make_pair(&F, Contents));
2860  TU->setHasExternalLexicalStorage(true);
2861  break;
2862  }
2863 
2864  case UPDATE_VISIBLE: {
2865  unsigned Idx = 0;
2866  serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2867  auto *Data = (const unsigned char*)Blob.data();
2868  PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2869  // If we've already loaded the decl, perform the updates when we finish
2870  // loading this block.
2871  if (Decl *D = GetExistingDecl(ID))
2872  PendingUpdateRecords.push_back(
2873  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2874  break;
2875  }
2876 
2877  case IDENTIFIER_TABLE:
2878  F.IdentifierTableData = Blob.data();
2879  if (Record[0]) {
2881  (const unsigned char *)F.IdentifierTableData + Record[0],
2882  (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2883  (const unsigned char *)F.IdentifierTableData,
2884  ASTIdentifierLookupTrait(*this, F));
2885 
2886  PP.getIdentifierTable().setExternalIdentifierLookup(this);
2887  }
2888  break;
2889 
2890  case IDENTIFIER_OFFSET: {
2891  if (F.LocalNumIdentifiers != 0) {
2892  Error("duplicate IDENTIFIER_OFFSET record in AST file");
2893  return Failure;
2894  }
2895  F.IdentifierOffsets = (const uint32_t *)Blob.data();
2896  F.LocalNumIdentifiers = Record[0];
2897  unsigned LocalBaseIdentifierID = Record[1];
2898  F.BaseIdentifierID = getTotalNumIdentifiers();
2899 
2900  if (F.LocalNumIdentifiers > 0) {
2901  // Introduce the global -> local mapping for identifiers within this
2902  // module.
2903  GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2904  &F));
2905 
2906  // Introduce the local -> global mapping for identifiers within this
2907  // module.
2909  std::make_pair(LocalBaseIdentifierID,
2910  F.BaseIdentifierID - LocalBaseIdentifierID));
2911 
2912  IdentifiersLoaded.resize(IdentifiersLoaded.size()
2913  + F.LocalNumIdentifiers);
2914  }
2915  break;
2916  }
2917 
2919  F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2920  break;
2921 
2923  // FIXME: Skip reading this record if our ASTConsumer doesn't care
2924  // about "interesting" decls (for instance, if we're building a module).
2925  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2926  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2927  break;
2928 
2929  case MODULAR_CODEGEN_DECLS:
2930  // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2931  // them (ie: if we're not codegenerating this module).
2932  if (F.Kind == MK_MainFile)
2933  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2934  EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2935  break;
2936 
2937  case SPECIAL_TYPES:
2938  if (SpecialTypes.empty()) {
2939  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2940  SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2941  break;
2942  }
2943 
2944  if (SpecialTypes.size() != Record.size()) {
2945  Error("invalid special-types record");
2946  return Failure;
2947  }
2948 
2949  for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2950  serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2951  if (!SpecialTypes[I])
2952  SpecialTypes[I] = ID;
2953  // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2954  // merge step?
2955  }
2956  break;
2957 
2958  case STATISTICS:
2959  TotalNumStatements += Record[0];
2960  TotalNumMacros += Record[1];
2961  TotalLexicalDeclContexts += Record[2];
2962  TotalVisibleDeclContexts += Record[3];
2963  break;
2964 
2966  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2967  UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2968  break;
2969 
2970  case DELEGATING_CTORS:
2971  for (unsigned I = 0, N = Record.size(); I != N; ++I)
2972  DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2973  break;
2974 
2976  if (Record.size() % 4 != 0) {
2977  Error("invalid weak identifiers record");
2978  return Failure;
2979  }
2980 
2981  // FIXME: Ignore weak undeclared identifiers from non-original PCH
2982  // files. This isn't the way to do it :)
2983  WeakUndeclaredIdentifiers.clear();
2984 
2985  // Translate the weak, undeclared identifiers into global IDs.
2986  for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2987  WeakUndeclaredIdentifiers.push_back(
2988  getGlobalIdentifierID(F, Record[I++]));
2989  WeakUndeclaredIdentifiers.push_back(
2990  getGlobalIdentifierID(F, Record[I++]));
2991  WeakUndeclaredIdentifiers.push_back(
2992  ReadSourceLocation(F, Record, I).getRawEncoding());
2993  WeakUndeclaredIdentifiers.push_back(Record[I++]);
2994  }
2995  break;
2996 
2997  case SELECTOR_OFFSETS: {
2998  F.SelectorOffsets = (const uint32_t *)Blob.data();
2999  F.LocalNumSelectors = Record[0];
3000  unsigned LocalBaseSelectorID = Record[1];
3001  F.BaseSelectorID = getTotalNumSelectors();
3002 
3003  if (F.LocalNumSelectors > 0) {
3004  // Introduce the global -> local mapping for selectors within this
3005  // module.
3006  GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3007 
3008  // Introduce the local -> global mapping for selectors within this
3009  // module.
3011  std::make_pair(LocalBaseSelectorID,
3012  F.BaseSelectorID - LocalBaseSelectorID));
3013 
3014  SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3015  }
3016  break;
3017  }
3018 
3019  case METHOD_POOL:
3020  F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3021  if (Record[0])
3024  F.SelectorLookupTableData + Record[0],
3026  ASTSelectorLookupTrait(*this, F));
3027  TotalNumMethodPoolEntries += Record[1];
3028  break;
3029 
3031  if (!Record.empty()) {
3032  for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3033  ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3034  Record[Idx++]));
3035  ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3036  getRawEncoding());
3037  }
3038  }
3039  break;
3040 
3041  case PP_CONDITIONAL_STACK:
3042  if (!Record.empty()) {
3043  unsigned Idx = 0, End = Record.size() - 1;
3044  bool ReachedEOFWhileSkipping = Record[Idx++];
3046  if (ReachedEOFWhileSkipping) {
3047  SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3048  SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3049  bool FoundNonSkipPortion = Record[Idx++];
3050  bool FoundElse = Record[Idx++];
3051  SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3052  SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3053  FoundElse, ElseLoc);
3054  }
3055  SmallVector<PPConditionalInfo, 4> ConditionalStack;
3056  while (Idx < End) {
3057  auto Loc = ReadSourceLocation(F, Record, Idx);
3058  bool WasSkipping = Record[Idx++];
3059  bool FoundNonSkip = Record[Idx++];
3060  bool FoundElse = Record[Idx++];
3061  ConditionalStack.push_back(
3062  {Loc, WasSkipping, FoundNonSkip, FoundElse});
3063  }
3064  PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3065  }
3066  break;
3067 
3068  case PP_COUNTER_VALUE:
3069  if (!Record.empty() && Listener)
3070  Listener->ReadCounter(F, Record[0]);
3071  break;
3072 
3073  case FILE_SORTED_DECLS:
3074  F.FileSortedDecls = (const DeclID *)Blob.data();
3075  F.NumFileSortedDecls = Record[0];
3076  break;
3077 
3078  case SOURCE_LOCATION_OFFSETS: {
3079  F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3080  F.LocalNumSLocEntries = Record[0];
3081  unsigned SLocSpaceSize = Record[1];
3082  std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3083  SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3084  SLocSpaceSize);
3085  if (!F.SLocEntryBaseID) {
3086  Error("ran out of source locations");
3087  break;
3088  }
3089  // Make our entry in the range map. BaseID is negative and growing, so
3090  // we invert it. Because we invert it, though, we need the other end of
3091  // the range.
3092  unsigned RangeStart =
3093  unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3094  GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3096 
3097  // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3098  assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3099  GlobalSLocOffsetMap.insert(
3100  std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3101  - SLocSpaceSize,&F));
3102 
3103  // Initialize the remapping table.
3104  // Invalid stays invalid.
3105  F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3106  // This module. Base was 2 when being compiled.
3107  F.SLocRemap.insertOrReplace(std::make_pair(2U,
3108  static_cast<int>(F.SLocEntryBaseOffset - 2)));
3109 
3110  TotalNumSLocEntries += F.LocalNumSLocEntries;
3111  break;
3112  }
3113 
3114  case MODULE_OFFSET_MAP:
3115  F.ModuleOffsetMap = Blob;
3116  break;
3117 
3119  if (ParseLineTable(F, Record))
3120  return Failure;
3121  break;
3122 
3123  case SOURCE_LOCATION_PRELOADS: {
3124  // Need to transform from the local view (1-based IDs) to the global view,
3125  // which is based off F.SLocEntryBaseID.
3126  if (!F.PreloadSLocEntries.empty()) {
3127  Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3128  return Failure;
3129  }
3130 
3131  F.PreloadSLocEntries.swap(Record);
3132  break;
3133  }
3134 
3135  case EXT_VECTOR_DECLS:
3136  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3137  ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3138  break;
3139 
3140  case VTABLE_USES:
3141  if (Record.size() % 3 != 0) {
3142  Error("Invalid VTABLE_USES record");
3143  return Failure;
3144  }
3145 
3146  // Later tables overwrite earlier ones.
3147  // FIXME: Modules will have some trouble with this. This is clearly not
3148  // the right way to do this.
3149  VTableUses.clear();
3150 
3151  for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3152  VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3153  VTableUses.push_back(
3154  ReadSourceLocation(F, Record, Idx).getRawEncoding());
3155  VTableUses.push_back(Record[Idx++]);
3156  }
3157  break;
3158 
3160  if (PendingInstantiations.size() % 2 != 0) {
3161  Error("Invalid existing PendingInstantiations");
3162  return Failure;
3163  }
3164 
3165  if (Record.size() % 2 != 0) {
3166  Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3167  return Failure;
3168  }
3169 
3170  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3171  PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3172  PendingInstantiations.push_back(
3173  ReadSourceLocation(F, Record, I).getRawEncoding());
3174  }
3175  break;
3176 
3177  case SEMA_DECL_REFS:
3178  if (Record.size() != 3) {
3179  Error("Invalid SEMA_DECL_REFS block");
3180  return Failure;
3181  }
3182  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3183  SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3184  break;
3185 
3186  case PPD_ENTITIES_OFFSETS: {
3187  F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3188  assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3189  F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3190 
3191  unsigned LocalBasePreprocessedEntityID = Record[0];
3192 
3193  unsigned StartingID;
3194  if (!PP.getPreprocessingRecord())
3195  PP.createPreprocessingRecord();
3196  if (!PP.getPreprocessingRecord()->getExternalSource())
3197  PP.getPreprocessingRecord()->SetExternalSource(*this);
3198  StartingID
3199  = PP.getPreprocessingRecord()
3200  ->allocateLoadedEntities(F.NumPreprocessedEntities);
3201  F.BasePreprocessedEntityID = StartingID;
3202 
3203  if (F.NumPreprocessedEntities > 0) {
3204  // Introduce the global -> local mapping for preprocessed entities in
3205  // this module.
3206  GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3207 
3208  // Introduce the local -> global mapping for preprocessed entities in
3209  // this module.
3211  std::make_pair(LocalBasePreprocessedEntityID,
3212  F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3213  }
3214 
3215  break;
3216  }
3217 
3218  case DECL_UPDATE_OFFSETS:
3219  if (Record.size() % 2 != 0) {
3220  Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3221  return Failure;
3222  }
3223  for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3224  GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3225  DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3226 
3227  // If we've already loaded the decl, perform the updates when we finish
3228  // loading this block.
3229  if (Decl *D = GetExistingDecl(ID))
3230  PendingUpdateRecords.push_back(
3231  PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3232  }
3233  break;
3234 
3235  case OBJC_CATEGORIES_MAP:
3236  if (F.LocalNumObjCCategoriesInMap != 0) {
3237  Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3238  return Failure;
3239  }
3240 
3241  F.LocalNumObjCCategoriesInMap = Record[0];
3242  F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3243  break;
3244 
3245  case OBJC_CATEGORIES:
3246  F.ObjCCategories.swap(Record);
3247  break;
3248 
3250  // Later tables overwrite earlier ones.
3251  // FIXME: Modules will have trouble with this.
3252  CUDASpecialDeclRefs.clear();
3253  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3254  CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3255  break;
3256 
3257  case HEADER_SEARCH_TABLE:
3258  F.HeaderFileInfoTableData = Blob.data();
3259  F.LocalNumHeaderFileInfos = Record[1];
3260  if (Record[0]) {
3263  (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3264  (const unsigned char *)F.HeaderFileInfoTableData,
3265  HeaderFileInfoTrait(*this, F,
3266  &PP.getHeaderSearchInfo(),
3267  Blob.data() + Record[2]));
3268 
3269  PP.getHeaderSearchInfo().SetExternalSource(this);
3270  if (!PP.getHeaderSearchInfo().getExternalLookup())
3271  PP.getHeaderSearchInfo().SetExternalLookup(this);
3272  }
3273  break;
3274 
3275  case FP_PRAGMA_OPTIONS:
3276  // Later tables overwrite earlier ones.
3277  FPPragmaOptions.swap(Record);
3278  break;
3279 
3280  case OPENCL_EXTENSIONS:
3281  for (unsigned I = 0, E = Record.size(); I != E; ) {
3282  auto Name = ReadString(Record, I);
3283  auto &Opt = OpenCLExtensions.OptMap[Name];
3284  Opt.Supported = Record[I++] != 0;
3285  Opt.Enabled = Record[I++] != 0;
3286  Opt.Avail = Record[I++];
3287  Opt.Core = Record[I++];
3288  }
3289  break;
3290 
3292  for (unsigned I = 0, E = Record.size(); I != E;) {
3293  auto TypeID = static_cast<::TypeID>(Record[I++]);
3294  auto *Type = GetType(TypeID).getTypePtr();
3295  auto NumExt = static_cast<unsigned>(Record[I++]);
3296  for (unsigned II = 0; II != NumExt; ++II) {
3297  auto Ext = ReadString(Record, I);
3298  OpenCLTypeExtMap[Type].insert(Ext);
3299  }
3300  }
3301  break;
3302 
3304  for (unsigned I = 0, E = Record.size(); I != E;) {
3305  auto DeclID = static_cast<::DeclID>(Record[I++]);
3306  auto *Decl = GetDecl(DeclID);
3307  auto NumExt = static_cast<unsigned>(Record[I++]);
3308  for (unsigned II = 0; II != NumExt; ++II) {
3309  auto Ext = ReadString(Record, I);
3310  OpenCLDeclExtMap[Decl].insert(Ext);
3311  }
3312  }
3313  break;
3314 
3315  case TENTATIVE_DEFINITIONS:
3316  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3317  TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3318  break;
3319 
3320  case KNOWN_NAMESPACES:
3321  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3322  KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3323  break;
3324 
3325  case UNDEFINED_BUT_USED:
3326  if (UndefinedButUsed.size() % 2 != 0) {
3327  Error("Invalid existing UndefinedButUsed");
3328  return Failure;
3329  }
3330 
3331  if (Record.size() % 2 != 0) {
3332  Error("invalid undefined-but-used record");
3333  return Failure;
3334  }
3335  for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3336  UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3337  UndefinedButUsed.push_back(
3338  ReadSourceLocation(F, Record, I).getRawEncoding());
3339  }
3340  break;
3341 
3343  for (unsigned I = 0, N = Record.size(); I != N;) {
3344  DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3345  const uint64_t Count = Record[I++];
3346  DelayedDeleteExprs.push_back(Count);
3347  for (uint64_t C = 0; C < Count; ++C) {
3348  DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3349  bool IsArrayForm = Record[I++] == 1;
3350  DelayedDeleteExprs.push_back(IsArrayForm);
3351  }
3352  }
3353  break;
3354 
3355  case IMPORTED_MODULES:
3356  if (!F.isModule()) {
3357  // If we aren't loading a module (which has its own exports), make
3358  // all of the imported modules visible.
3359  // FIXME: Deal with macros-only imports.
3360  for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3361  unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3362  SourceLocation Loc = ReadSourceLocation(F, Record, I);
3363  if (GlobalID) {
3364  ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3365  if (DeserializationListener)
3366  DeserializationListener->ModuleImportRead(GlobalID, Loc);
3367  }
3368  }
3369  }
3370  break;
3371 
3372  case MACRO_OFFSET: {
3373  if (F.LocalNumMacros != 0) {
3374  Error("duplicate MACRO_OFFSET record in AST file");
3375  return Failure;
3376  }
3377  F.MacroOffsets = (const uint32_t *)Blob.data();
3378  F.LocalNumMacros = Record[0];
3379  unsigned LocalBaseMacroID = Record[1];
3380  F.BaseMacroID = getTotalNumMacros();
3381 
3382  if (F.LocalNumMacros > 0) {
3383  // Introduce the global -> local mapping for macros within this module.
3384  GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3385 
3386  // Introduce the local -> global mapping for macros within this module.
3388  std::make_pair(LocalBaseMacroID,
3389  F.BaseMacroID - LocalBaseMacroID));
3390 
3391  MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3392  }
3393  break;
3394  }
3395 
3396  case LATE_PARSED_TEMPLATE:
3397  LateParsedTemplates.append(Record.begin(), Record.end());
3398  break;
3399 
3401  if (Record.size() != 1) {
3402  Error("invalid pragma optimize record");
3403  return Failure;
3404  }
3405  OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3406  break;
3407 
3409  if (Record.size() != 1) {
3410  Error("invalid pragma ms_struct record");
3411  return Failure;
3412  }
3413  PragmaMSStructState = Record[0];
3414  break;
3415 
3417  if (Record.size() != 2) {
3418  Error("invalid pragma ms_struct record");
3419  return Failure;
3420  }
3421  PragmaMSPointersToMembersState = Record[0];
3422  PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3423  break;
3424 
3426  for (unsigned I = 0, N = Record.size(); I != N; ++I)
3427  UnusedLocalTypedefNameCandidates.push_back(
3428  getGlobalDeclID(F, Record[I]));
3429  break;
3430 
3432  if (Record.size() != 1) {
3433  Error("invalid cuda pragma options record");
3434  return Failure;
3435  }
3436  ForceCUDAHostDeviceDepth = Record[0];
3437  break;
3438 
3439  case PACK_PRAGMA_OPTIONS: {
3440  if (Record.size() < 3) {
3441  Error("invalid pragma pack record");
3442  return Failure;
3443  }
3444  PragmaPackCurrentValue = Record[0];
3445  PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3446  unsigned NumStackEntries = Record[2];
3447  unsigned Idx = 3;
3448  // Reset the stack when importing a new module.
3449  PragmaPackStack.clear();
3450  for (unsigned I = 0; I < NumStackEntries; ++I) {
3451  PragmaPackStackEntry Entry;
3452  Entry.Value = Record[Idx++];
3453  Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3454  Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3455  PragmaPackStrings.push_back(ReadString(Record, Idx));
3456  Entry.SlotLabel = PragmaPackStrings.back();
3457  PragmaPackStack.push_back(Entry);
3458  }
3459  break;
3460  }
3461  }
3462  }
3463 }
3464 
3465 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3466  assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3467 
3468  // Additional remapping information.
3469  const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3470  const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3471  F.ModuleOffsetMap = StringRef();
3472 
3473  // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3474  if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3475  F.SLocRemap.insert(std::make_pair(0U, 0));
3476  F.SLocRemap.insert(std::make_pair(2U, 1));
3477  }
3478 
3479  // Continuous range maps we may be updating in our module.
3480  using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3481  RemapBuilder SLocRemap(F.SLocRemap);
3482  RemapBuilder IdentifierRemap(F.IdentifierRemap);
3483  RemapBuilder MacroRemap(F.MacroRemap);
3484  RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3485  RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3486  RemapBuilder SelectorRemap(F.SelectorRemap);
3487  RemapBuilder DeclRemap(F.DeclRemap);
3488  RemapBuilder TypeRemap(F.TypeRemap);
3489 
3490  while (Data < DataEnd) {
3491  // FIXME: Looking up dependency modules by filename is horrible. Let's
3492  // start fixing this with prebuilt and explicit modules and see how it
3493  // goes...
3494  using namespace llvm::support;
3495  ModuleKind Kind = static_cast<ModuleKind>(
3496  endian::readNext<uint8_t, little, unaligned>(Data));
3497  uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3498  StringRef Name = StringRef((const char*)Data, Len);
3499  Data += Len;
3500  ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3501  ? ModuleMgr.lookupByModuleName(Name)
3502  : ModuleMgr.lookupByFileName(Name));
3503  if (!OM) {
3504  std::string Msg =
3505  "SourceLocation remap refers to unknown module, cannot find ";
3506  Msg.append(Name);
3507  Error(Msg);
3508  return;
3509  }
3510 
3511  uint32_t SLocOffset =
3512  endian::readNext<uint32_t, little, unaligned>(Data);
3513  uint32_t IdentifierIDOffset =
3514  endian::readNext<uint32_t, little, unaligned>(Data);
3515  uint32_t MacroIDOffset =
3516  endian::readNext<uint32_t, little, unaligned>(Data);
3517  uint32_t PreprocessedEntityIDOffset =
3518  endian::readNext<uint32_t, little, unaligned>(Data);
3519  uint32_t SubmoduleIDOffset =
3520  endian::readNext<uint32_t, little, unaligned>(Data);
3521  uint32_t SelectorIDOffset =
3522  endian::readNext<uint32_t, little, unaligned>(Data);
3523  uint32_t DeclIDOffset =
3524  endian::readNext<uint32_t, little, unaligned>(Data);
3525  uint32_t TypeIndexOffset =
3526  endian::readNext<uint32_t, little, unaligned>(Data);
3527 
3528  uint32_t None = std::numeric_limits<uint32_t>::max();
3529 
3530  auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3531  RemapBuilder &Remap) {
3532  if (Offset != None)
3533  Remap.insert(std::make_pair(Offset,
3534  static_cast<int>(BaseOffset - Offset)));
3535  };
3536  mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3537  mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3538  mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3539  mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3540  PreprocessedEntityRemap);
3541  mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3542  mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3543  mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3544  mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3545 
3546  // Global -> local mappings.
3547  F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3548  }
3549 }
3550 
3552 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3553  const ModuleFile *ImportedBy,
3554  unsigned ClientLoadCapabilities) {
3555  unsigned Idx = 0;
3556  F.ModuleMapPath = ReadPath(F, Record, Idx);
3557 
3558  // Try to resolve ModuleName in the current header search context and
3559  // verify that it is found in the same module map file as we saved. If the
3560  // top-level AST file is a main file, skip this check because there is no
3561  // usable header search context.
3562  assert(!F.ModuleName.empty() &&
3563  "MODULE_NAME should come before MODULE_MAP_FILE");
3564  if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3565  // An implicitly-loaded module file should have its module listed in some
3566  // module map file that we've already loaded.
3567  Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3568  auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3569  const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3570  if (!ModMap) {
3571  assert(ImportedBy && "top-level import should be verified");
3572  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3573  if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3574  // This module was defined by an imported (explicit) module.
3575  Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3576  << ASTFE->getName();
3577  } else {
3578  // This module was built with a different module map.
3579  Diag(diag::err_imported_module_not_found)
3580  << F.ModuleName << F.FileName << ImportedBy->FileName
3581  << F.ModuleMapPath;
3582  // In case it was imported by a PCH, there's a chance the user is
3583  // just missing to include the search path to the directory containing
3584  // the modulemap.
3585  if (ImportedBy->Kind == MK_PCH)
3586  Diag(diag::note_imported_by_pch_module_not_found)
3587  << llvm::sys::path::parent_path(F.ModuleMapPath);
3588  }
3589  }
3590  return OutOfDate;
3591  }
3592 
3593  assert(M->Name == F.ModuleName && "found module with different name");
3594 
3595  // Check the primary module map file.
3596  const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3597  if (StoredModMap == nullptr || StoredModMap != ModMap) {
3598  assert(ModMap && "found module is missing module map file");
3599  assert(ImportedBy && "top-level import should be verified");
3600  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3601  Diag(diag::err_imported_module_modmap_changed)
3602  << F.ModuleName << ImportedBy->FileName
3603  << ModMap->getName() << F.ModuleMapPath;
3604  return OutOfDate;
3605  }
3606 
3607  llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3608  for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3609  // FIXME: we should use input files rather than storing names.
3610  std::string Filename = ReadPath(F, Record, Idx);
3611  const FileEntry *F =
3612  FileMgr.getFile(Filename, false, false);
3613  if (F == nullptr) {
3614  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3615  Error("could not find file '" + Filename +"' referenced by AST file");
3616  return OutOfDate;
3617  }
3618  AdditionalStoredMaps.insert(F);
3619  }
3620 
3621  // Check any additional module map files (e.g. module.private.modulemap)
3622  // that are not in the pcm.
3623  if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3624  for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3625  // Remove files that match
3626  // Note: SmallPtrSet::erase is really remove
3627  if (!AdditionalStoredMaps.erase(ModMap)) {
3628  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3629  Diag(diag::err_module_different_modmap)
3630  << F.ModuleName << /*new*/0 << ModMap->getName();
3631  return OutOfDate;
3632  }
3633  }
3634  }
3635 
3636  // Check any additional module map files that are in the pcm, but not
3637  // found in header search. Cases that match are already removed.
3638  for (const FileEntry *ModMap : AdditionalStoredMaps) {
3639  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3640  Diag(diag::err_module_different_modmap)
3641  << F.ModuleName << /*not new*/1 << ModMap->getName();
3642  return OutOfDate;
3643  }
3644  }
3645 
3646  if (Listener)
3647  Listener->ReadModuleMapFile(F.ModuleMapPath);
3648  return Success;
3649 }
3650 
3651 /// \brief Move the given method to the back of the global list of methods.
3653  // Find the entry for this selector in the method pool.
3654  Sema::GlobalMethodPool::iterator Known
3655  = S.MethodPool.find(Method->getSelector());
3656  if (Known == S.MethodPool.end())
3657  return;
3658 
3659  // Retrieve the appropriate method list.
3660  ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3661  : Known->second.second;
3662  bool Found = false;
3663  for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3664  if (!Found) {
3665  if (List->getMethod() == Method) {
3666  Found = true;
3667  } else {
3668  // Keep searching.
3669  continue;
3670  }
3671  }
3672 
3673  if (List->getNext())
3674  List->setMethod(List->getNext()->getMethod());
3675  else
3676  List->setMethod(Method);
3677  }
3678 }
3679 
3680 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3681  assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3682  for (Decl *D : Names) {
3683  bool wasHidden = D->isHidden();
3684  D->setVisibleDespiteOwningModule();
3685 
3686  if (wasHidden && SemaObj) {
3687  if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3688  moveMethodToBackOfGlobalList(*SemaObj, Method);
3689  }
3690  }
3691  }
3692 }
3693 
3695  Module::NameVisibilityKind NameVisibility,
3696  SourceLocation ImportLoc) {
3697  llvm::SmallPtrSet<Module *, 4> Visited;
3699  Stack.push_back(Mod);
3700  while (!Stack.empty()) {
3701  Mod = Stack.pop_back_val();
3702 
3703  if (NameVisibility <= Mod->NameVisibility) {
3704  // This module already has this level of visibility (or greater), so
3705  // there is nothing more to do.
3706  continue;
3707  }
3708 
3709  if (!Mod->isAvailable()) {
3710  // Modules that aren't available cannot be made visible.
3711  continue;
3712  }
3713 
3714  // Update the module's name visibility.
3715  Mod->NameVisibility = NameVisibility;
3716 
3717  // If we've already deserialized any names from this module,
3718  // mark them as visible.
3719  HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3720  if (Hidden != HiddenNamesMap.end()) {
3721  auto HiddenNames = std::move(*Hidden);
3722  HiddenNamesMap.erase(Hidden);
3723  makeNamesVisible(HiddenNames.second, HiddenNames.first);
3724  assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3725  "making names visible added hidden names");
3726  }
3727 
3728  // Push any exported modules onto the stack to be marked as visible.
3729  SmallVector<Module *, 16> Exports;
3730  Mod->getExportedModules(Exports);
3732  I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3733  Module *Exported = *I;
3734  if (Visited.insert(Exported).second)
3735  Stack.push_back(Exported);
3736  }
3737  }
3738 }
3739 
3740 /// We've merged the definition \p MergedDef into the existing definition
3741 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3742 /// visible.
3744  NamedDecl *MergedDef) {
3745  // FIXME: This doesn't correctly handle the case where MergedDef is visible
3746  // in modules other than its owning module. We should instead give the
3747  // ASTContext a list of merged definitions for Def.
3748  if (Def->isHidden()) {
3749  // If MergedDef is visible or becomes visible, make the definition visible.
3750  if (!MergedDef->isHidden())
3752  else if (getContext().getLangOpts().ModulesLocalVisibility) {
3753  getContext().mergeDefinitionIntoModule(
3754  Def, MergedDef->getImportedOwningModule(),
3755  /*NotifyListeners*/ false);
3756  PendingMergedDefinitionsToDeduplicate.insert(Def);
3757  } else {
3758  auto SubmoduleID = MergedDef->getOwningModuleID();
3759  assert(SubmoduleID && "hidden definition in no module");
3760  HiddenNamesMap[getSubmodule(SubmoduleID)].push_back(Def);
3761  }
3762  }
3763 }
3764 
3766  if (GlobalIndex)
3767  return false;
3768 
3769  if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3770  !PP.getLangOpts().Modules)
3771  return true;
3772 
3773  // Try to load the global index.
3774  TriedLoadingGlobalIndex = true;
3775  StringRef ModuleCachePath
3776  = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3777  std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3778  = GlobalModuleIndex::readIndex(ModuleCachePath);
3779  if (!Result.first)
3780  return true;
3781 
3782  GlobalIndex.reset(Result.first);
3783  ModuleMgr.setGlobalIndex(GlobalIndex.get());
3784  return false;
3785 }
3786 
3788  return PP.getLangOpts().Modules && UseGlobalIndex &&
3789  !hasGlobalIndex() && TriedLoadingGlobalIndex;
3790 }
3791 
3793  // Overwrite the timestamp file contents so that file's mtime changes.
3794  std::string TimestampFilename = MF.getTimestampFilename();
3795  std::error_code EC;
3796  llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3797  if (EC)
3798  return;
3799  OS << "Timestamp file\n";
3800  OS.close();
3801  OS.clear_error(); // Avoid triggering a fatal error.
3802 }
3803 
3804 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3805 /// cursor into the start of the given block ID, returning false on success and
3806 /// true on failure.
3807 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3808  while (true) {
3809  llvm::BitstreamEntry Entry = Cursor.advance();
3810  switch (Entry.Kind) {
3812  case llvm::BitstreamEntry::EndBlock:
3813  return true;
3814 
3815  case llvm::BitstreamEntry::Record:
3816  // Ignore top-level records.
3817  Cursor.skipRecord(Entry.ID);
3818  break;
3819 
3820  case llvm::BitstreamEntry::SubBlock:
3821  if (Entry.ID == BlockID) {
3822  if (Cursor.EnterSubBlock(BlockID))
3823  return true;
3824  // Found it!
3825  return false;
3826  }
3827 
3828  if (Cursor.SkipBlock())
3829  return true;
3830  }
3831  }
3832 }
3833 
3835  ModuleKind Type,
3836  SourceLocation ImportLoc,
3837  unsigned ClientLoadCapabilities,
3840  SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3841 
3842  // Defer any pending actions until we get to the end of reading the AST file.
3843  Deserializing AnASTFile(this);
3844 
3845  // Bump the generation number.
3846  unsigned PreviousGeneration = 0;
3847  if (ContextObj)
3848  PreviousGeneration = incrementGeneration(*ContextObj);
3849 
3850  unsigned NumModules = ModuleMgr.size();
3852  switch (ASTReadResult ReadResult =
3853  ReadASTCore(FileName, Type, ImportLoc,
3854  /*ImportedBy=*/nullptr, Loaded, 0, 0,
3855  ASTFileSignature(), ClientLoadCapabilities)) {
3856  case Failure:
3857  case Missing:
3858  case OutOfDate:
3859  case VersionMismatch:
3860  case ConfigurationMismatch:
3861  case HadErrors: {
3862  llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3863  for (const ImportedModule &IM : Loaded)
3864  LoadedSet.insert(IM.Mod);
3865 
3866  ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3867  PP.getLangOpts().Modules
3868  ? &PP.getHeaderSearchInfo().getModuleMap()
3869  : nullptr);
3870 
3871  // If we find that any modules are unusable, the global index is going
3872  // to be out-of-date. Just remove it.
3873  GlobalIndex.reset();
3874  ModuleMgr.setGlobalIndex(nullptr);
3875  return ReadResult;
3876  }
3877  case Success:
3878  break;
3879  }
3880 
3881  // Here comes stuff that we only do once the entire chain is loaded.
3882 
3883  // Load the AST blocks of all of the modules that we loaded.
3884  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3885  MEnd = Loaded.end();
3886  M != MEnd; ++M) {
3887  ModuleFile &F = *M->Mod;
3888 
3889  // Read the AST block.
3890  if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3891  return Result;
3892 
3893  // Read the extension blocks.
3895  if (ASTReadResult Result = ReadExtensionBlock(F))
3896  return Result;
3897  }
3898 
3899  // Once read, set the ModuleFile bit base offset and update the size in
3900  // bits of all files we've seen.
3901  F.GlobalBitOffset = TotalModulesSizeInBits;
3902  TotalModulesSizeInBits += F.SizeInBits;
3903  GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3904 
3905  // Preload SLocEntries.
3906  for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3907  int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3908  // Load it through the SourceManager and don't call ReadSLocEntry()
3909  // directly because the entry may have already been loaded in which case
3910  // calling ReadSLocEntry() directly would trigger an assertion in
3911  // SourceManager.
3912  SourceMgr.getLoadedSLocEntryByID(Index);
3913  }
3914 
3915  // Map the original source file ID into the ID space of the current
3916  // compilation.
3917  if (F.OriginalSourceFileID.isValid()) {
3918  F.OriginalSourceFileID = FileID::get(
3919  F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3920  }
3921 
3922  // Preload all the pending interesting identifiers by marking them out of
3923  // date.
3924  for (auto Offset : F.PreloadIdentifierOffsets) {
3925  const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3927 
3928  ASTIdentifierLookupTrait Trait(*this, F);
3929  auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3930  auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3931  auto &II = PP.getIdentifierTable().getOwn(Key);
3932  II.setOutOfDate(true);
3933 
3934  // Mark this identifier as being from an AST file so that we can track
3935  // whether we need to serialize it.
3936  markIdentifierFromAST(*this, II);
3937 
3938  // Associate the ID with the identifier so that the writer can reuse it.
3939  auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3940  SetIdentifierInfo(ID, &II);
3941  }
3942  }
3943 
3944  // Setup the import locations and notify the module manager that we've
3945  // committed to these module files.
3946  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3947  MEnd = Loaded.end();
3948  M != MEnd; ++M) {
3949  ModuleFile &F = *M->Mod;
3950 
3951  ModuleMgr.moduleFileAccepted(&F);
3952 
3953  // Set the import location.
3954  F.DirectImportLoc = ImportLoc;
3955  // FIXME: We assume that locations from PCH / preamble do not need
3956  // any translation.
3957  if (!M->ImportedBy)
3958  F.ImportLoc = M->ImportLoc;
3959  else
3960  F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3961  }
3962 
3963  if (!PP.getLangOpts().CPlusPlus ||
3964  (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
3965  Type != MK_PrebuiltModule)) {
3966  // Mark all of the identifiers in the identifier table as being out of date,
3967  // so that various accessors know to check the loaded modules when the
3968  // identifier is used.
3969  //
3970  // For C++ modules, we don't need information on many identifiers (just
3971  // those that provide macros or are poisoned), so we mark all of
3972  // the interesting ones via PreloadIdentifierOffsets.
3973  for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3974  IdEnd = PP.getIdentifierTable().end();
3975  Id != IdEnd; ++Id)
3976  Id->second->setOutOfDate(true);
3977  }
3978  // Mark selectors as out of date.
3979  for (auto Sel : SelectorGeneration)
3980  SelectorOutOfDate[Sel.first] = true;
3981 
3982  // Resolve any unresolved module exports.
3983  for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3984  UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3985  SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3986  Module *ResolvedMod = getSubmodule(GlobalID);
3987 
3988  switch (Unresolved.Kind) {
3989  case UnresolvedModuleRef::Conflict:
3990  if (ResolvedMod) {
3991  Module::Conflict Conflict;
3992  Conflict.Other = ResolvedMod;
3993  Conflict.Message = Unresolved.String.str();
3994  Unresolved.Mod->Conflicts.push_back(Conflict);
3995  }
3996  continue;
3997 
3998  case UnresolvedModuleRef::Import:
3999  if (ResolvedMod)
4000  Unresolved.Mod->Imports.insert(ResolvedMod);
4001  continue;
4002 
4003  case UnresolvedModuleRef::Export:
4004  if (ResolvedMod || Unresolved.IsWildcard)
4005  Unresolved.Mod->Exports.push_back(
4006  Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4007  continue;
4008  }
4009  }
4010  UnresolvedModuleRefs.clear();
4011 
4012  if (Imported)
4013  Imported->append(ImportedModules.begin(),
4014  ImportedModules.end());
4015 
4016  // FIXME: How do we load the 'use'd modules? They may not be submodules.
4017  // Might be unnecessary as use declarations are only used to build the
4018  // module itself.
4019 
4020  if (ContextObj)
4021  InitializeContext();
4022 
4023  if (SemaObj)
4024  UpdateSema();
4025 
4026  if (DeserializationListener)
4027  DeserializationListener->ReaderInitialized(this);
4028 
4029  ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4030  if (PrimaryModule.OriginalSourceFileID.isValid()) {
4031  // If this AST file is a precompiled preamble, then set the
4032  // preamble file ID of the source manager to the file source file
4033  // from which the preamble was built.
4034  if (Type == MK_Preamble) {
4035  SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4036  } else if (Type == MK_MainFile) {
4037  SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4038  }
4039  }
4040 
4041  // For any Objective-C class definitions we have already loaded, make sure
4042  // that we load any additional categories.
4043  if (ContextObj) {
4044  for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4045  loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4046  ObjCClassesLoaded[I],
4047  PreviousGeneration);
4048  }
4049  }
4050 
4051  if (PP.getHeaderSearchInfo()
4052  .getHeaderSearchOpts()
4053  .ModulesValidateOncePerBuildSession) {
4054  // Now we are certain that the module and all modules it depends on are
4055  // up to date. Create or update timestamp files for modules that are
4056  // located in the module cache (not for PCH files that could be anywhere
4057  // in the filesystem).
4058  for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4059  ImportedModule &M = Loaded[I];
4060  if (M.Mod->Kind == MK_ImplicitModule) {
4061  updateModuleTimestamp(*M.Mod);
4062  }
4063  }
4064  }
4065 
4066  return Success;
4067 }
4068 
4069 static ASTFileSignature readASTFileSignature(StringRef PCH);
4070 
4071 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4072 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4073  return Stream.canSkipToPos(4) &&
4074  Stream.Read(8) == 'C' &&
4075  Stream.Read(8) == 'P' &&
4076  Stream.Read(8) == 'C' &&
4077  Stream.Read(8) == 'H';
4078 }
4079 
4081  switch (Kind) {
4082  case MK_PCH:
4083  return 0; // PCH
4084  case MK_ImplicitModule:
4085  case MK_ExplicitModule:
4086  case MK_PrebuiltModule:
4087  return 1; // module
4088  case MK_MainFile:
4089  case MK_Preamble:
4090  return 2; // main source file
4091  }
4092  llvm_unreachable("unknown module kind");
4093 }
4094 
4096 ASTReader::ReadASTCore(StringRef FileName,
4097  ModuleKind Type,
4098  SourceLocation ImportLoc,
4099  ModuleFile *ImportedBy,
4101  off_t ExpectedSize, time_t ExpectedModTime,
4102  ASTFileSignature ExpectedSignature,
4103  unsigned ClientLoadCapabilities) {
4104  ModuleFile *M;
4105  std::string ErrorStr;
4107  = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4108  getGeneration(), ExpectedSize, ExpectedModTime,
4109  ExpectedSignature, readASTFileSignature,
4110  M, ErrorStr);
4111 
4112  switch (AddResult) {
4114  return Success;
4115 
4117  // Load module file below.
4118  break;
4119 
4121  // The module file was missing; if the client can handle that, return
4122  // it.
4123  if (ClientLoadCapabilities & ARR_Missing)
4124  return Missing;
4125 
4126  // Otherwise, return an error.
4127  Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4128  << FileName << !ErrorStr.empty()
4129  << ErrorStr;
4130  return Failure;
4131 
4133  // We couldn't load the module file because it is out-of-date. If the
4134  // client can handle out-of-date, return it.
4135  if (ClientLoadCapabilities & ARR_OutOfDate)
4136  return OutOfDate;
4137 
4138  // Otherwise, return an error.
4139  Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4140  << FileName << !ErrorStr.empty()
4141  << ErrorStr;
4142  return Failure;
4143  }
4144 
4145  assert(M && "Missing module file");
4146 
4147  ModuleFile &F = *M;
4148  BitstreamCursor &Stream = F.Stream;
4149  Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4150  F.SizeInBits = F.Buffer->getBufferSize() * 8;
4151 
4152  // Sniff for the signature.
4153  if (!startsWithASTFileMagic(Stream)) {
4154  Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4155  << FileName;
4156  return Failure;
4157  }
4158 
4159  // This is used for compatibility with older PCH formats.
4160  bool HaveReadControlBlock = false;
4161  while (true) {
4162  llvm::BitstreamEntry Entry = Stream.advance();
4163 
4164  switch (Entry.Kind) {
4166  case llvm::BitstreamEntry::Record:
4167  case llvm::BitstreamEntry::EndBlock:
4168  Error("invalid record at top-level of AST file");
4169  return Failure;
4170 
4171  case llvm::BitstreamEntry::SubBlock:
4172  break;
4173  }
4174 
4175  switch (Entry.ID) {
4176  case CONTROL_BLOCK_ID:
4177  HaveReadControlBlock = true;
4178  switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4179  case Success:
4180  // Check that we didn't try to load a non-module AST file as a module.
4181  //
4182  // FIXME: Should we also perform the converse check? Loading a module as
4183  // a PCH file sort of works, but it's a bit wonky.
4184  if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4185  Type == MK_PrebuiltModule) &&
4186  F.ModuleName.empty()) {
4187  auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4188  if (Result != OutOfDate ||
4189  (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4190  Diag(diag::err_module_file_not_module) << FileName;
4191  return Result;
4192  }
4193  break;
4194 
4195  case Failure: return Failure;
4196  case Missing: return Missing;
4197  case OutOfDate: return OutOfDate;
4198  case VersionMismatch: return VersionMismatch;
4199  case ConfigurationMismatch: return ConfigurationMismatch;
4200  case HadErrors: return HadErrors;
4201  }
4202  break;
4203 
4204  case AST_BLOCK_ID:
4205  if (!HaveReadControlBlock) {
4206  if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4207  Diag(diag::err_pch_version_too_old);
4208  return VersionMismatch;
4209  }
4210 
4211  // Record that we've loaded this module.
4212  Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4213  return Success;
4214 
4216  // This block is handled using look-ahead during ReadControlBlock. We
4217  // shouldn't get here!
4218  Error("malformed block record in AST file");
4219  return Failure;
4220 
4221  default:
4222  if (Stream.SkipBlock()) {
4223  Error("malformed block record in AST file");
4224  return Failure;
4225  }
4226  break;
4227  }
4228  }
4229 
4230  return Success;
4231 }
4232 
4234 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4235  unsigned ClientLoadCapabilities) {
4236  const HeaderSearchOptions &HSOpts =
4237  PP.getHeaderSearchInfo().getHeaderSearchOpts();
4238  bool AllowCompatibleConfigurationMismatch =
4240 
4241  ASTReadResult Result = readUnhashedControlBlockImpl(
4242  &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4243  Listener.get(),
4244  WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4245 
4246  // If F was directly imported by another module, it's implicitly validated by
4247  // the importing module.
4248  if (DisableValidation || WasImportedBy ||
4249  (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4250  return Success;
4251 
4252  if (Result == Failure) {
4253  Error("malformed block record in AST file");
4254  return Failure;
4255  }
4256 
4257  if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4258  // If this module has already been finalized in the PCMCache, we're stuck
4259  // with it; we can only load a single version of each module.
4260  //
4261  // This can happen when a module is imported in two contexts: in one, as a
4262  // user module; in another, as a system module (due to an import from
4263  // another module marked with the [system] flag). It usually indicates a
4264  // bug in the module map: this module should also be marked with [system].
4265  //
4266  // If -Wno-system-headers (the default), and the first import is as a
4267  // system module, then validation will fail during the as-user import,
4268  // since -Werror flags won't have been validated. However, it's reasonable
4269  // to treat this consistently as a system module.
4270  //
4271  // If -Wsystem-headers, the PCM on disk was built with
4272  // -Wno-system-headers, and the first import is as a user module, then
4273  // validation will fail during the as-system import since the PCM on disk
4274  // doesn't guarantee that -Werror was respected. However, the -Werror
4275  // flags were checked during the initial as-user import.
4276  if (PCMCache.isBufferFinal(F.FileName)) {
4277  Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4278  return Success;
4279  }
4280  }
4281 
4282  return Result;
4283 }
4284 
4285 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4286  ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4287  bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4288  bool ValidateDiagnosticOptions) {
4289  // Initialize a stream.
4290  BitstreamCursor Stream(StreamData);
4291 
4292  // Sniff for the signature.
4293  if (!startsWithASTFileMagic(Stream))
4294  return Failure;
4295 
4296  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4298  return Failure;
4299 
4300  // Read all of the records in the options block.
4301  RecordData Record;
4302  ASTReadResult Result = Success;
4303  while (true) {
4304  llvm::BitstreamEntry Entry = Stream.advance();
4305 
4306  switch (Entry.Kind) {
4308  case llvm::BitstreamEntry::SubBlock:
4309  return Failure;
4310 
4311  case llvm::BitstreamEntry::EndBlock:
4312  return Result;
4313 
4314  case llvm::BitstreamEntry::Record:
4315  // The interesting case.
4316  break;
4317  }
4318 
4319  // Read and process a record.
4320  Record.clear();
4321  switch (
4322  (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4323  case SIGNATURE:
4324  if (F)
4325  std::copy(Record.begin(), Record.end(), F->Signature.data());
4326  break;
4327  case DIAGNOSTIC_OPTIONS: {
4328  bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4329  if (Listener && ValidateDiagnosticOptions &&
4330  !AllowCompatibleConfigurationMismatch &&
4331  ParseDiagnosticOptions(Record, Complain, *Listener))
4332  Result = OutOfDate; // Don't return early. Read the signature.
4333  break;
4334  }
4335  case DIAG_PRAGMA_MAPPINGS:
4336  if (!F)
4337  break;
4338  if (F->PragmaDiagMappings.empty())
4339  F->PragmaDiagMappings.swap(Record);
4340  else
4341  F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4342  Record.begin(), Record.end());
4343  break;
4344  }
4345  }
4346 }
4347 
4348 /// Parse a record and blob containing module file extension metadata.
4350  const SmallVectorImpl<uint64_t> &Record,
4351  StringRef Blob,
4352  ModuleFileExtensionMetadata &Metadata) {
4353  if (Record.size() < 4) return true;
4354 
4355  Metadata.MajorVersion = Record[0];
4356  Metadata.MinorVersion = Record[1];
4357 
4358  unsigned BlockNameLen = Record[2];
4359  unsigned UserInfoLen = Record[3];
4360 
4361  if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4362 
4363  Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4364  Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4365  Blob.data() + BlockNameLen + UserInfoLen);
4366  return false;
4367 }
4368 
4369 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4370  BitstreamCursor &Stream = F.Stream;
4371 
4372  RecordData Record;
4373  while (true) {
4374  llvm::BitstreamEntry Entry = Stream.advance();
4375  switch (Entry.Kind) {
4376  case llvm::BitstreamEntry::SubBlock:
4377  if (Stream.SkipBlock())
4378  return Failure;
4379 
4380  continue;
4381 
4382  case llvm::BitstreamEntry::EndBlock:
4383  return Success;
4384 
4386  return HadErrors;
4387 
4388  case llvm::BitstreamEntry::Record:
4389  break;
4390  }
4391 
4392  Record.clear();
4393  StringRef Blob;
4394  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4395  switch (RecCode) {
4396  case EXTENSION_METADATA: {
4397  ModuleFileExtensionMetadata Metadata;
4398  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4399  return Failure;
4400 
4401  // Find a module file extension with this block name.
4402  auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4403  if (Known == ModuleFileExtensions.end()) break;
4404 
4405  // Form a reader.
4406  if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4407  F, Stream)) {
4408  F.ExtensionReaders.push_back(std::move(Reader));
4409  }
4410 
4411  break;
4412  }
4413  }
4414  }
4415 
4416  return Success;
4417 }
4418 
4420  assert(ContextObj && "no context to initialize");
4421  ASTContext &Context = *ContextObj;
4422 
4423  // If there's a listener, notify them that we "read" the translation unit.
4424  if (DeserializationListener)
4425  DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4426  Context.getTranslationUnitDecl());
4427 
4428  // FIXME: Find a better way to deal with collisions between these
4429  // built-in types. Right now, we just ignore the problem.
4430 
4431  // Load the special types.
4432  if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4433  if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4434  if (!Context.CFConstantStringTypeDecl)
4435  Context.setCFConstantStringType(GetType(String));
4436  }
4437 
4438  if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4439  QualType FileType = GetType(File);
4440  if (FileType.isNull()) {
4441  Error("FILE type is NULL");
4442  return;
4443  }
4444 
4445  if (!Context.FILEDecl) {
4446  if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4447  Context.setFILEDecl(Typedef->getDecl());
4448  else {
4449  const TagType *Tag = FileType->getAs<TagType>();
4450  if (!Tag) {
4451  Error("Invalid FILE type in AST file");
4452  return;
4453  }
4454  Context.setFILEDecl(Tag->getDecl());
4455  }
4456  }
4457  }
4458 
4459  if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4460  QualType Jmp_bufType = GetType(Jmp_buf);
4461  if (Jmp_bufType.isNull()) {
4462  Error("jmp_buf type is NULL");
4463  return;
4464  }
4465 
4466  if (!Context.jmp_bufDecl) {
4467  if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4468  Context.setjmp_bufDecl(Typedef->getDecl());
4469  else {
4470  const TagType *Tag = Jmp_bufType->getAs<TagType>();
4471  if (!Tag) {
4472  Error("Invalid jmp_buf type in AST file");
4473  return;
4474  }
4475  Context.setjmp_bufDecl(Tag->getDecl());
4476  }
4477  }
4478  }
4479 
4480  if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4481  QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4482  if (Sigjmp_bufType.isNull()) {
4483  Error("sigjmp_buf type is NULL");
4484  return;
4485  }
4486 
4487  if (!Context.sigjmp_bufDecl) {
4488  if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4489  Context.setsigjmp_bufDecl(Typedef->getDecl());
4490  else {
4491  const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4492  assert(Tag && "Invalid sigjmp_buf type in AST file");
4493  Context.setsigjmp_bufDecl(Tag->getDecl());
4494  }
4495  }
4496  }
4497 
4498  if (unsigned ObjCIdRedef
4499  = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4500  if (Context.ObjCIdRedefinitionType.isNull())
4501  Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4502  }
4503 
4504  if (unsigned ObjCClassRedef
4505  = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4506  if (Context.ObjCClassRedefinitionType.isNull())
4507  Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4508  }
4509 
4510  if (unsigned ObjCSelRedef
4511  = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4512  if (Context.ObjCSelRedefinitionType.isNull())
4513  Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4514  }
4515 
4516  if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4517  QualType Ucontext_tType = GetType(Ucontext_t);
4518  if (Ucontext_tType.isNull()) {
4519  Error("ucontext_t type is NULL");
4520  return;
4521  }
4522 
4523  if (!Context.ucontext_tDecl) {
4524  if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4525  Context.setucontext_tDecl(Typedef->getDecl());
4526  else {
4527  const TagType *Tag = Ucontext_tType->getAs<TagType>();
4528  assert(Tag && "Invalid ucontext_t type in AST file");
4529  Context.setucontext_tDecl(Tag->getDecl());
4530  }
4531  }
4532  }
4533  }
4534 
4535  ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4536 
4537  // If there were any CUDA special declarations, deserialize them.
4538  if (!CUDASpecialDeclRefs.empty()) {
4539  assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4540  Context.setcudaConfigureCallDecl(
4541  cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4542  }
4543 
4544  // Re-export any modules that were imported by a non-module AST file.
4545  // FIXME: This does not make macro-only imports visible again.
4546  for (auto &Import : ImportedModules) {
4547  if (Module *Imported = getSubmodule(Import.ID)) {
4548  makeModuleVisible(Imported, Module::AllVisible,
4549  /*ImportLoc=*/Import.ImportLoc);
4550  if (Import.ImportLoc.isValid())
4551  PP.makeModuleVisible(Imported, Import.ImportLoc);
4552  // FIXME: should we tell Sema to make the module visible too?
4553  }
4554  }
4555  ImportedModules.clear();
4556 }
4557 
4559  // Nothing to do for now.
4560 }
4561 
4562 /// \brief Reads and return the signature record from \p PCH's control block, or
4563 /// else returns 0.
4565  BitstreamCursor Stream(PCH);
4566  if (!startsWithASTFileMagic(Stream))
4567  return ASTFileSignature();
4568 
4569  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4571  return ASTFileSignature();
4572 
4573  // Scan for SIGNATURE inside the diagnostic options block.
4574  ASTReader::RecordData Record;
4575  while (true) {
4576  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4577  if (Entry.Kind != llvm::BitstreamEntry::Record)
4578  return ASTFileSignature();
4579 
4580  Record.clear();
4581  StringRef Blob;
4582  if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4583  return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4584  (uint32_t)Record[3], (uint32_t)Record[4]}}};
4585  }
4586 }
4587 
4588 /// \brief Retrieve the name of the original source file name
4589 /// directly from the AST file, without actually loading the AST
4590 /// file.
4592  const std::string &ASTFileName, FileManager &FileMgr,
4593  const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4594  // Open the AST file.
4595  auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4596  if (!Buffer) {
4597  Diags.Report(diag::err_fe_unable_to_read_pch_file)
4598  << ASTFileName << Buffer.getError().message();
4599  return std::string();
4600  }
4601 
4602  // Initialize the stream
4603  BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4604 
4605  // Sniff for the signature.
4606  if (!startsWithASTFileMagic(Stream)) {
4607  Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4608  return std::string();
4609  }
4610 
4611  // Scan for the CONTROL_BLOCK_ID block.
4612  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4613  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4614  return std::string();
4615  }
4616 
4617  // Scan for ORIGINAL_FILE inside the control block.
4618  RecordData Record;
4619  while (true) {
4620  llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4621  if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4622  return std::string();
4623 
4624  if (Entry.Kind != llvm::BitstreamEntry::Record) {
4625  Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4626  return std::string();
4627  }
4628 
4629  Record.clear();
4630  StringRef Blob;
4631  if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4632  return Blob.str();
4633  }
4634 }
4635 
4636 namespace {
4637 
4638  class SimplePCHValidator : public ASTReaderListener {
4639  const LangOptions &ExistingLangOpts;
4640  const TargetOptions &ExistingTargetOpts;
4641  const PreprocessorOptions &ExistingPPOpts;
4642  std::string ExistingModuleCachePath;
4643  FileManager &FileMgr;
4644 
4645  public:
4646  SimplePCHValidator(const LangOptions &ExistingLangOpts,
4647  const TargetOptions &ExistingTargetOpts,
4648  const PreprocessorOptions &ExistingPPOpts,
4649  StringRef ExistingModuleCachePath,
4650  FileManager &FileMgr)
4651  : ExistingLangOpts(ExistingLangOpts),
4652  ExistingTargetOpts(ExistingTargetOpts),
4653  ExistingPPOpts(ExistingPPOpts),
4654  ExistingModuleCachePath(ExistingModuleCachePath),
4655  FileMgr(FileMgr) {}
4656 
4657  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4658  bool AllowCompatibleDifferences) override {
4659  return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4660  AllowCompatibleDifferences);
4661  }
4662 
4663  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4664  bool AllowCompatibleDifferences) override {
4665  return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4666  AllowCompatibleDifferences);
4667  }
4668 
4669  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4670  StringRef SpecificModuleCachePath,
4671  bool Complain) override {
4672  return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4673  ExistingModuleCachePath,
4674  nullptr, ExistingLangOpts);
4675  }
4676 
4677  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4678  bool Complain,
4679  std::string &SuggestedPredefines) override {
4680  return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4681  SuggestedPredefines, ExistingLangOpts);
4682  }
4683  };
4684 
4685 } // namespace
4686 
4688  StringRef Filename, FileManager &FileMgr,
4689  const PCHContainerReader &PCHContainerRdr,
4690  bool FindModuleFileExtensions,
4691  ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4692  // Open the AST file.
4693  // FIXME: This allows use of the VFS; we do not allow use of the
4694  // VFS when actually loading a module.
4695  auto Buffer = FileMgr.getBufferForFile(Filename);
4696  if (!Buffer) {
4697  return true;
4698  }
4699 
4700  // Initialize the stream
4701  StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4702  BitstreamCursor Stream(Bytes);
4703 
4704  // Sniff for the signature.
4705  if (!startsWithASTFileMagic(Stream))
4706  return true;
4707 
4708  // Scan for the CONTROL_BLOCK_ID block.
4709  if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4710  return true;
4711 
4712  bool NeedsInputFiles = Listener.needsInputFileVisitation();
4713  bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4714  bool NeedsImports = Listener.needsImportVisitation();
4715  BitstreamCursor InputFilesCursor;
4716 
4717  RecordData Record;
4718  std::string ModuleDir;
4719  bool DoneWithControlBlock = false;
4720  while (!DoneWithControlBlock) {
4721  llvm::BitstreamEntry Entry = Stream.advance();
4722 
4723  switch (Entry.Kind) {
4724  case llvm::BitstreamEntry::SubBlock: {
4725  switch (Entry.ID) {
4726  case OPTIONS_BLOCK_ID: {
4727  std::string IgnoredSuggestedPredefines;
4728  if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4729  /*AllowCompatibleConfigurationMismatch*/ false,
4730  Listener, IgnoredSuggestedPredefines) != Success)
4731  return true;
4732  break;
4733  }
4734 
4735  case INPUT_FILES_BLOCK_ID:
4736  InputFilesCursor = Stream;
4737  if (Stream.SkipBlock() ||
4738  (NeedsInputFiles &&
4739  ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4740  return true;
4741  break;
4742 
4743  default:
4744  if (Stream.SkipBlock())
4745  return true;
4746  break;
4747  }
4748 
4749  continue;
4750  }
4751 
4752  case llvm::BitstreamEntry::EndBlock:
4753  DoneWithControlBlock = true;
4754  break;
4755 
4757  return true;
4758 
4759  case llvm::BitstreamEntry::Record:
4760  break;
4761  }
4762 
4763  if (DoneWithControlBlock) break;
4764 
4765  Record.clear();
4766  StringRef Blob;
4767  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4768  switch ((ControlRecordTypes)RecCode) {
4769  case METADATA:
4770  if (Record[0] != VERSION_MAJOR)
4771  return true;
4772  if (Listener.ReadFullVersionInformation(Blob))
4773  return true;
4774  break;
4775  case MODULE_NAME:
4776  Listener.ReadModuleName(Blob);
4777  break;
4778  case MODULE_DIRECTORY:
4779  ModuleDir = Blob;
4780  break;
4781  case MODULE_MAP_FILE: {
4782  unsigned Idx = 0;
4783  auto Path = ReadString(Record, Idx);
4784  ResolveImportedPath(Path, ModuleDir);
4785  Listener.ReadModuleMapFile(Path);
4786  break;
4787  }
4788  case INPUT_FILE_OFFSETS: {
4789  if (!NeedsInputFiles)
4790  break;
4791 
4792  unsigned NumInputFiles = Record[0];
4793  unsigned NumUserFiles = Record[1];
4794  const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
4795  for (unsigned I = 0; I != NumInputFiles; ++I) {
4796  // Go find this input file.
4797  bool isSystemFile = I >= NumUserFiles;
4798 
4799  if (isSystemFile && !NeedsSystemInputFiles)
4800  break; // the rest are system input files
4801 
4802  BitstreamCursor &Cursor = InputFilesCursor;
4803  SavedStreamPosition SavedPosition(Cursor);
4804  Cursor.JumpToBit(InputFileOffs[I]);
4805 
4806  unsigned Code = Cursor.ReadCode();
4807  RecordData Record;
4808  StringRef Blob;
4809  bool shouldContinue = false;
4810  switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4811  case INPUT_FILE:
4812  bool Overridden = static_cast<bool>(Record[3]);
4813  std::string Filename = Blob;
4814  ResolveImportedPath(Filename, ModuleDir);
4815  shouldContinue = Listener.visitInputFile(
4816  Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4817  break;
4818  }
4819  if (!shouldContinue)
4820  break;
4821  }
4822  break;
4823  }
4824 
4825  case IMPORTS: {
4826  if (!NeedsImports)
4827  break;
4828 
4829  unsigned Idx = 0, N = Record.size();
4830  while (Idx < N) {
4831  // Read information about the AST file.
4832  Idx += 5; // ImportLoc, Size, ModTime, Signature
4833  SkipString(Record, Idx); // Module name; FIXME: pass to listener?
4834  std::string Filename = ReadString(Record, Idx);
4835  ResolveImportedPath(Filename, ModuleDir);
4836  Listener.visitImport(Filename);
4837  }
4838  break;
4839  }
4840 
4841  default:
4842  // No other validation to perform.
4843  break;
4844  }
4845  }
4846 
4847  // Look for module file extension blocks, if requested.
4848  if (FindModuleFileExtensions) {
4849  BitstreamCursor SavedStream = Stream;
4850  while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4851  bool DoneWithExtensionBlock = false;
4852  while (!DoneWithExtensionBlock) {
4853  llvm::BitstreamEntry Entry = Stream.advance();
4854 
4855  switch (Entry.Kind) {
4856  case llvm::BitstreamEntry::SubBlock:
4857  if (Stream.SkipBlock())
4858  return true;
4859 
4860  continue;
4861 
4862  case llvm::BitstreamEntry::EndBlock:
4863  DoneWithExtensionBlock = true;
4864  continue;
4865 
4867  return true;
4868 
4869  case llvm::BitstreamEntry::Record:
4870  break;
4871  }
4872 
4873  Record.clear();
4874  StringRef Blob;
4875  unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4876  switch (RecCode) {
4877  case EXTENSION_METADATA: {
4878  ModuleFileExtensionMetadata Metadata;
4879  if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4880  return true;
4881 
4882  Listener.readModuleFileExtension(Metadata);
4883  break;
4884  }
4885  }
4886  }
4887  }
4888  Stream = SavedStream;
4889  }
4890 
4891  // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4892  if (readUnhashedControlBlockImpl(
4893  nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4894  /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4895  ValidateDiagnosticOptions) != Success)
4896  return true;
4897 
4898  return false;
4899 }
4900 
4902  const PCHContainerReader &PCHContainerRdr,
4903  const LangOptions &LangOpts,
4904  const TargetOptions &TargetOpts,
4905  const PreprocessorOptions &PPOpts,
4906  StringRef ExistingModuleCachePath) {
4907  SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4908  ExistingModuleCachePath, FileMgr);
4909  return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4910  /*FindModuleFileExtensions=*/false,
4911  validator,
4912  /*ValidateDiagnosticOptions=*/true);
4913 }
4914 
4916 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4917  // Enter the submodule block.
4918  if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4919  Error("malformed submodule block record in AST file");
4920  return Failure;
4921  }
4922 
4923  ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4924  bool First = true;
4925  Module *CurrentModule = nullptr;
4926  RecordData Record;
4927  while (true) {
4928  llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4929 
4930  switch (Entry.Kind) {
4931  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4933  Error("malformed block record in AST file");
4934  return Failure;
4935  case llvm::BitstreamEntry::EndBlock:
4936  return Success;
4937  case llvm::BitstreamEntry::Record:
4938  // The interesting case.
4939  break;
4940  }
4941 
4942  // Read a record.
4943  StringRef Blob;
4944  Record.clear();
4945  auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4946 
4947  if ((Kind == SUBMODULE_METADATA) != First) {
4948  Error("submodule metadata record should be at beginning of block");
4949  return Failure;
4950  }
4951  First = false;
4952 
4953  // Submodule information is only valid if we have a current module.
4954  // FIXME: Should we error on these cases?
4955  if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4957  continue;
4958 
4959  switch (Kind) {
4960  default: // Default behavior: ignore.
4961  break;
4962 
4963  case SUBMODULE_DEFINITION: {
4964  if (Record.size() < 8) {
4965  Error("malformed module definition");
4966  return Failure;
4967  }
4968 
4969  StringRef Name = Blob;
4970  unsigned Idx = 0;
4971  SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4972  SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4973  Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
4974  bool IsFramework = Record[Idx++];
4975  bool IsExplicit = Record[Idx++];
4976  bool IsSystem = Record[Idx++];
4977  bool IsExternC = Record[Idx++];
4978  bool InferSubmodules = Record[Idx++];
4979  bool InferExplicitSubmodules = Record[Idx++];
4980  bool InferExportWildcard = Record[Idx++];
4981  bool ConfigMacrosExhaustive = Record[Idx++];
4982 
4983  Module *ParentModule = nullptr;
4984  if (Parent)
4985  ParentModule = getSubmodule(Parent);
4986 
4987  // Retrieve this (sub)module from the module map, creating it if
4988  // necessary.
4989  CurrentModule =
4990  ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
4991  .first;
4992 
4993  // FIXME: set the definition loc for CurrentModule, or call
4994  // ModMap.setInferredModuleAllowedBy()
4995 
4996  SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4997  if (GlobalIndex >= SubmodulesLoaded.size() ||
4998  SubmodulesLoaded[GlobalIndex]) {
4999  Error("too many submodules");
5000  return Failure;
5001  }
5002 
5003  if (!ParentModule) {
5004  if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5005  if (CurFile != F.File) {
5006  if (!Diags.isDiagnosticInFlight()) {
5007  Diag(diag::err_module_file_conflict)
5008  << CurrentModule->getTopLevelModuleName()
5009  << CurFile->getName()
5010  << F.File->getName();
5011  }
5012  return Failure;
5013  }
5014  }
5015 
5016  CurrentModule->setASTFile(F.File);
5017  CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5018  }
5019 
5020  CurrentModule->Kind = Kind;
5021  CurrentModule->Signature = F.Signature;
5022  CurrentModule->IsFromModuleFile = true;
5023  CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5024  CurrentModule->IsExternC = IsExternC;
5025  CurrentModule->InferSubmodules = InferSubmodules;
5026  CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5027  CurrentModule->InferExportWildcard = InferExportWildcard;
5028  CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5029  if (DeserializationListener)
5030  DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5031 
5032  SubmodulesLoaded[GlobalIndex] = CurrentModule;
5033 
5034  // Clear out data that will be replaced by what is in the module file.
5035  CurrentModule->LinkLibraries.clear();
5036  CurrentModule->ConfigMacros.clear();
5037  CurrentModule->UnresolvedConflicts.clear();
5038  CurrentModule->Conflicts.clear();
5039 
5040  // The module is available unless it's missing a requirement; relevant
5041  // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5042  // Missing headers that were present when the module was built do not
5043  // make it unavailable -- if we got this far, this must be an explicitly
5044  // imported module file.
5045  CurrentModule->Requirements.clear();
5046  CurrentModule->MissingHeaders.clear();
5047  CurrentModule->IsMissingRequirement =
5048  ParentModule && ParentModule->IsMissingRequirement;
5049  CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5050  break;
5051  }
5052 
5054  std::string Filename = Blob;
5055  ResolveImportedPath(F, Filename);
5056  if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5057  if (!CurrentModule->getUmbrellaHeader())
5058  ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5059  else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5060  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5061  Error("mismatched umbrella headers in submodule");
5062  return OutOfDate;
5063  }
5064  }
5065  break;
5066  }
5067 
5068  case SUBMODULE_HEADER:
5071  // We lazily associate headers with their modules via the HeaderInfo table.
5072  // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5073  // of complete filenames or remove it entirely.
5074  break;
5075 
5078  // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5079  // them here.
5080  break;
5081 
5082  case SUBMODULE_TOPHEADER:
5083  CurrentModule->addTopHeaderFilename(Blob);
5084  break;
5085 
5086  case SUBMODULE_UMBRELLA_DIR: {
5087  std::string Dirname = Blob;
5088  ResolveImportedPath(F, Dirname);
5089  if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5090  if (!CurrentModule->getUmbrellaDir())
5091  ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5092  else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5093  if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5094  Error("mismatched umbrella directories in submodule");
5095  return OutOfDate;
5096  }
5097  }
5098  break;
5099  }
5100 
5101  case SUBMODULE_METADATA: {
5102  F.BaseSubmoduleID = getTotalNumSubmodules();
5103  F.LocalNumSubmodules = Record[0];
5104  unsigned LocalBaseSubmoduleID = Record[1];
5105  if (F.LocalNumSubmodules > 0) {
5106  // Introduce the global -> local mapping for submodules within this
5107  // module.
5108  GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5109 
5110  // Introduce the local -> global mapping for submodules within this
5111  // module.
5113  std::make_pair(LocalBaseSubmoduleID,
5114  F.BaseSubmoduleID - LocalBaseSubmoduleID));
5115 
5116  SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5117  }
5118  break;
5119  }
5120 
5121  case SUBMODULE_IMPORTS:
5122  for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5123  UnresolvedModuleRef Unresolved;
5124  Unresolved.File = &F;
5125  Unresolved.Mod = CurrentModule;
5126  Unresolved.ID = Record[Idx];
5127  Unresolved.Kind = UnresolvedModuleRef::Import;
5128  Unresolved.IsWildcard = false;
5129  UnresolvedModuleRefs.push_back(Unresolved);
5130  }
5131  break;
5132 
5133  case SUBMODULE_EXPORTS:
5134  for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5135  UnresolvedModuleRef Unresolved;
5136  Unresolved.File = &F;
5137  Unresolved.Mod = CurrentModule;
5138  Unresolved.ID = Record[Idx];
5139  Unresolved.Kind = UnresolvedModuleRef::Export;
5140  Unresolved.IsWildcard = Record[Idx + 1];
5141  UnresolvedModuleRefs.push_back(Unresolved);
5142  }
5143 
5144  // Once we've loaded the set of exports, there's no reason to keep
5145  // the parsed, unresolved exports around.
5146  CurrentModule->UnresolvedExports.clear();
5147  break;
5148 
5149  case SUBMODULE_REQUIRES:
5150  CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5151  PP.getTargetInfo());
5152  break;
5153 
5155  CurrentModule->LinkLibraries.push_back(
5156  Module::LinkLibrary(Blob, Record[0]));
5157  break;
5158 
5160  CurrentModule->ConfigMacros.push_back(Blob.str());
5161  break;
5162 
5163  case SUBMODULE_CONFLICT: {
5164  UnresolvedModuleRef Unresolved;
5165  Unresolved.File = &F;
5166  Unresolved.Mod = CurrentModule;
5167  Unresolved.ID = Record[0];
5168  Unresolved.Kind = UnresolvedModuleRef::Conflict;
5169  Unresolved.IsWildcard = false;
5170  Unresolved.String = Blob;
5171  UnresolvedModuleRefs.push_back(Unresolved);
5172  break;
5173  }
5174 
5175  case SUBMODULE_INITIALIZERS: {
5176  if (!ContextObj)
5177  break;
5179  for (auto &ID : Record)
5180  Inits.push_back(getGlobalDeclID(F, ID));
5181  ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5182  break;
5183  }
5184 
5185  case SUBMODULE_EXPORT_AS:
5186  CurrentModule->ExportAsModule = Blob.str();
5187  break;
5188  }
5189  }
5190 }
5191 
5192 /// \brief Parse the record that corresponds to a LangOptions data
5193 /// structure.
5194 ///
5195 /// This routine parses the language options from the AST file and then gives
5196 /// them to the AST listener if one is set.
5197 ///
5198 /// \returns true if the listener deems the file unacceptable, false otherwise.
5199 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5200  bool Complain,
5201  ASTReaderListener &Listener,
5202  bool AllowCompatibleDifferences) {
5203  LangOptions LangOpts;
5204  unsigned Idx = 0;
5205 #define LANGOPT(Name, Bits, Default, Description) \
5206  LangOpts.Name = Record[Idx++];
5207 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5208  LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5209 #include "clang/Basic/LangOptions.def"
5210 #define SANITIZER(NAME, ID) \
5211  LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5212 #include "clang/Basic/Sanitizers.def"
5213 
5214  for (unsigned N = Record[Idx++]; N; --N)
5215  LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5216 
5217  ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5218  VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5219  LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5220 
5221  LangOpts.CurrentModule = ReadString(Record, Idx);
5222 
5223  // Comment options.
5224  for (unsigned N = Record[Idx++]; N; --N) {
5225  LangOpts.CommentOpts.BlockCommandNames.push_back(
5226  ReadString(Record, Idx));
5227  }
5228  LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5229 
5230  // OpenMP offloading options.
5231  for (unsigned N = Record[Idx++]; N; --N) {
5232  LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5233  }
5234 
5235  LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5236 
5237  return Listener.ReadLanguageOptions(LangOpts, Complain,
5238  AllowCompatibleDifferences);
5239 }
5240 
5241 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5242  ASTReaderListener &Listener,
5243  bool AllowCompatibleDifferences) {
5244  unsigned Idx = 0;
5245  TargetOptions TargetOpts;
5246  TargetOpts.Triple = ReadString(Record, Idx);
5247  TargetOpts.CPU = ReadString(Record, Idx);
5248  TargetOpts.ABI = ReadString(Record, Idx);
5249  for (unsigned N = Record[Idx++]; N; --N) {
5250  TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5251  }
5252  for (unsigned N = Record[Idx++]; N; --N) {
5253  TargetOpts.Features.push_back(ReadString(Record, Idx));
5254  }
5255 
5256  return Listener.ReadTargetOptions(TargetOpts, Complain,
5257  AllowCompatibleDifferences);
5258 }
5259 
5260 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5261  ASTReaderListener &Listener) {
5263  unsigned Idx = 0;
5264 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5265 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5266  DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5267 #include "clang/Basic/DiagnosticOptions.def"
5268 
5269  for (unsigned N = Record[Idx++]; N; --N)
5270  DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5271  for (unsigned N = Record[Idx++]; N; --N)
5272  DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5273 
5274  return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5275 }
5276 
5277 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5278  ASTReaderListener &Listener) {
5279  FileSystemOptions FSOpts;
5280  unsigned Idx = 0;
5281  FSOpts.WorkingDir = ReadString(Record, Idx);
5282  return Listener.ReadFileSystemOptions(FSOpts, Complain);
5283 }
5284 
5285 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5286  bool Complain,
5287  ASTReaderListener &Listener) {
5288  HeaderSearchOptions HSOpts;
5289  unsigned Idx = 0;
5290  HSOpts.Sysroot = ReadString(Record, Idx);
5291 
5292  // Include entries.
5293  for (unsigned N = Record[Idx++]; N; --N) {
5294  std::string Path = ReadString(Record, Idx);
5296  = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5297  bool IsFramework = Record[Idx++];
5298  bool IgnoreSysRoot = Record[Idx++];
5299  HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5300  IgnoreSysRoot);
5301  }
5302 
5303  // System header prefixes.
5304  for (unsigned N = Record[Idx++]; N; --N) {
5305  std::string Prefix = ReadString(Record, Idx);
5306  bool IsSystemHeader = Record[Idx++];
5307  HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5308  }
5309 
5310  HSOpts.ResourceDir = ReadString(Record, Idx);
5311  HSOpts.ModuleCachePath = ReadString(Record, Idx);
5312  HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5313  HSOpts.DisableModuleHash = Record[Idx++];
5314  HSOpts.ImplicitModuleMaps = Record[Idx++];
5315  HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5316  HSOpts.UseBuiltinIncludes = Record[Idx++];
5317  HSOpts.UseStandardSystemIncludes = Record[Idx++];
5318  HSOpts.UseStandardCXXIncludes = Record[Idx++];
5319  HSOpts.UseLibcxx = Record[Idx++];
5320  std::string SpecificModuleCachePath = ReadString(Record, Idx);
5321 
5322  return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5323  Complain);
5324 }
5325 
5326 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5327  bool Complain,
5328  ASTReaderListener &Listener,
5329  std::string &SuggestedPredefines) {
5330  PreprocessorOptions PPOpts;
5331  unsigned Idx = 0;
5332 
5333  // Macro definitions/undefs
5334  for (unsigned N = Record[Idx++]; N; --N) {
5335  std::string Macro = ReadString(Record, Idx);
5336  bool IsUndef = Record[Idx++];
5337  PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5338  }
5339 
5340  // Includes
5341  for (unsigned N = Record[Idx++]; N; --N) {
5342  PPOpts.Includes.push_back(ReadString(Record, Idx));
5343  }
5344 
5345  // Macro Includes
5346  for (unsigned N = Record[Idx++]; N; --N) {
5347  PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5348  }
5349 
5350  PPOpts.UsePredefines = Record[Idx++];
5351  PPOpts.DetailedRecord = Record[Idx++];
5352  PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5353  PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
5354  PPOpts.ObjCXXARCStandardLibrary =
5355  static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5356  SuggestedPredefines.clear();
5357  return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5358  SuggestedPredefines);
5359 }
5360 
5361 std::pair<ModuleFile *, unsigned>
5362 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5364  I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5365  assert(I != GlobalPreprocessedEntityMap.end() &&
5366  "Corrupted global preprocessed entity map");
5367  ModuleFile *M = I->second;
5368  unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5369  return std::make_pair(M, LocalIndex);
5370 }
5371 
5372 llvm::iterator_range<PreprocessingRecord::iterator>
5373 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5374  if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5375  return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5377 
5378  return llvm::make_range(PreprocessingRecord::iterator(),
5380 }
5381 
5382 llvm::iterator_range<ASTReader::ModuleDeclIterator>
5384  return llvm::make_range(
5385  ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5386  ModuleDeclIterator(this, &Mod,
5387  Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5388 }
5389 
5391  PreprocessedEntityID PPID = Index+1;
5392  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5393  ModuleFile &M = *PPInfo.first;
5394  unsigned LocalIndex = PPInfo.second;
5395  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5396 
5397  if (!PP.getPreprocessingRecord()) {
5398  Error("no preprocessing record");
5399  return nullptr;
5400  }
5401 
5403  M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5404 
5405  llvm::BitstreamEntry Entry =
5406  M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5407  if (Entry.Kind != llvm::BitstreamEntry::Record)
5408  return nullptr;
5409 
5410  // Read the record.
5411  SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5412  TranslateSourceLocation(M, PPOffs.getEnd()));
5413  PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5414  StringRef Blob;
5415  RecordData Record;
5418  Entry.ID, Record, &Blob);
5419  switch (RecType) {
5420  case PPD_MACRO_EXPANSION: {
5421  bool isBuiltin = Record[0];
5422  IdentifierInfo *Name = nullptr;
5423  MacroDefinitionRecord *Def = nullptr;
5424  if (isBuiltin)
5425  Name = getLocalIdentifier(M, Record[1]);
5426  else {
5427  PreprocessedEntityID GlobalID =
5428  getGlobalPreprocessedEntityID(M, Record[1]);
5429  Def = cast<MacroDefinitionRecord>(
5430  PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5431  }
5432 
5433  MacroExpansion *ME;
5434  if (isBuiltin)
5435  ME = new (PPRec) MacroExpansion(Name, Range);
5436  else
5437  ME = new (PPRec) MacroExpansion(Def, Range);
5438 
5439  return ME;
5440  }
5441 
5442  case PPD_MACRO_DEFINITION: {
5443  // Decode the identifier info and then check again; if the macro is
5444  // still defined and associated with the identifier,
5445  IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5446  MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5447 
5448  if (DeserializationListener)
5449  DeserializationListener->MacroDefinitionRead(PPID, MD);
5450 
5451  return MD;
5452  }
5453 
5454  case PPD_INCLUSION_DIRECTIVE: {
5455  const char *FullFileNameStart = Blob.data() + Record[0];
5456  StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5457  const FileEntry *File = nullptr;
5458  if (!FullFileName.empty())
5459  File = PP.getFileManager().getFile(FullFileName);
5460 
5461  // FIXME: Stable encoding
5463  = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5465  = new (PPRec) InclusionDirective(PPRec, Kind,
5466  StringRef(Blob.data(), Record[0]),
5467  Record[1], Record[3],
5468  File,
5469  Range);
5470  return ID;
5471  }
5472  }
5473 
5474  llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
5475 }
5476 
5477 /// \brief Find the next module that contains entities and return the ID
5478 /// of the first entry.
5479 ///
5480 /// \param SLocMapI points at a chunk of a module that contains no
5481 /// preprocessed entities or the entities it contains are not the ones we are
5482 /// looking for.
5483 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5484  GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5485  ++SLocMapI;
5487  EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5488  ModuleFile &M = *SLocMapI->second;
5490  return M.BasePreprocessedEntityID;
5491  }
5492 
5493  return getTotalNumPreprocessedEntities();
5494 }
5495 
5496 namespace {
5497 
5498 struct PPEntityComp {
5499  const ASTReader &Reader;
5500  ModuleFile &M;
5501 
5502  PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5503 
5504  bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5505  SourceLocation LHS = getLoc(L);
5506  SourceLocation RHS = getLoc(R);
5507  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5508  }
5509 
5510  bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5511  SourceLocation LHS = getLoc(L);
5512  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5513  }
5514 
5515  bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5516  SourceLocation RHS = getLoc(R);
5517  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5518  }
5519 
5520  SourceLocation getLoc(const PPEntityOffset &PPE) const {
5521  return Reader.TranslateSourceLocation(M, PPE.getBegin());
5522  }
5523 };
5524 
5525 } // namespace
5526 
5527 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5528  bool EndsAfter) const {
5529  if (SourceMgr.isLocalSourceLocation(Loc))
5530  return getTotalNumPreprocessedEntities();
5531 
5532  GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5533  SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5534  assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5535  "Corrupted global sloc offset map");
5536 
5537  if (SLocMapI->second->NumPreprocessedEntities == 0)
5538  return findNextPreprocessedEntity(SLocMapI);
5539 
5540  ModuleFile &M = *SLocMapI->second;
5541 
5542  using pp_iterator = const PPEntityOffset *;
5543 
5544  pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5545  pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5546 
5547  size_t Count = M.NumPreprocessedEntities;
5548  size_t Half;
5549  pp_iterator First = pp_begin;
5550  pp_iterator PPI;
5551 
5552  if (EndsAfter) {
5553  PPI = std::upper_bound(pp_begin, pp_end, Loc,
5554  PPEntityComp(*this, M));
5555  } else {
5556  // Do a binary search manually instead of using std::lower_bound because
5557  // The end locations of entities may be unordered (when a macro expansion
5558  // is inside another macro argument), but for this case it is not important
5559  // whether we get the first macro expansion or its containing macro.
5560  while (Count > 0) {
5561  Half = Count / 2;
5562  PPI = First;
5563  std::advance(PPI, Half);
5564  if (SourceMgr.isBeforeInTranslationUnit(
5565  TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5566  First = PPI;
5567  ++First;
5568  Count = Count - Half - 1;
5569  } else
5570  Count = Half;
5571  }
5572  }
5573 
5574  if (PPI == pp_end)
5575  return findNextPreprocessedEntity(SLocMapI);
5576 
5577  return M.BasePreprocessedEntityID + (PPI - pp_begin);
5578 }
5579 
5580 /// \brief Returns a pair of [Begin, End) indices of preallocated
5581 /// preprocessed entities that \arg Range encompasses.
5582 std::pair<unsigned, unsigned>
5584  if (Range.isInvalid())
5585  return std::make_pair(0,0);
5586  assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5587 
5588  PreprocessedEntityID BeginID =
5589  findPreprocessedEntity(Range.getBegin(), false);
5590  PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5591  return std::make_pair(BeginID, EndID);
5592 }
5593 
5594 /// \brief Optionally returns true or false if the preallocated preprocessed
5595 /// entity with index \arg Index came from file \arg FID.
5597  FileID FID) {
5598  if (FID.isInvalid())
5599  return false;
5600 
5601  std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5602  ModuleFile &M = *PPInfo.first;
5603  unsigned LocalIndex = PPInfo.second;
5604  const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5605 
5606  SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5607  if (Loc.isInvalid())
5608  return false;
5609 
5610  if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5611  return true;
5612  else
5613  return false;
5614 }
5615 
5616 namespace {
5617 
5618  /// \brief Visitor used to search for information about a header file.
5619  class HeaderFileInfoVisitor {
5620  const FileEntry *FE;
5622 
5623  public:
5624  explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5625 
5626  bool operator()(ModuleFile &M) {
5628  = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5629  if (!Table)
5630  return false;
5631 
5632  // Look in the on-disk hash table for an entry for this file name.
5633  HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5634  if (Pos == Table->end())
5635  return false;
5636 
5637  HFI = *Pos;
5638  return true;
5639  }
5640 
5641  Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5642  };
5643 
5644 } // namespace
5645 
5647  HeaderFileInfoVisitor Visitor(FE);
5648  ModuleMgr.visit(Visitor);
5649  if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5650  return *HFI;
5651 
5652  return HeaderFileInfo();
5653 }
5654 
5656  using DiagState = DiagnosticsEngine::DiagState;
5657  SmallVector<DiagState *, 32> DiagStates;
5658 
5659  for (ModuleFile &F : ModuleMgr) {
5660  unsigned Idx = 0;
5661  auto &Record = F.PragmaDiagMappings;
5662  if (Record.empty())
5663  continue;
5664 
5665  DiagStates.clear();
5666 
5667  auto ReadDiagState =
5668  [&](const DiagState &BasedOn, SourceLocation Loc,
5669  bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5670  unsigned BackrefID = Record[Idx++];
5671  if (BackrefID != 0)
5672  return DiagStates[BackrefID - 1];
5673 
5674  // A new DiagState was created here.
5675  Diag.DiagStates.push_back(BasedOn);
5676  DiagState *NewState = &Diag.DiagStates.back();
5677  DiagStates.push_back(NewState);
5678  unsigned Size = Record[Idx++];
5679  assert(Idx + Size * 2 <= Record.size() &&
5680  "Invalid data, not enough diag/map pairs");
5681  while (Size--) {
5682  unsigned DiagID = Record[Idx++];
5683  DiagnosticMapping NewMapping =
5684  DiagnosticMapping::deserialize(Record[Idx++]);
5685  if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5686  continue;
5687 
5688  DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5689 
5690  // If this mapping was specified as a warning but the severity was
5691  // upgraded due to diagnostic settings, simulate the current diagnostic
5692  // settings (and use a warning).
5693  if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5695  NewMapping.setUpgradedFromWarning(false);
5696  }
5697 
5698  Mapping = NewMapping;
5699  }
5700  return NewState;
5701  };
5702 
5703  // Read the first state.
5704  DiagState *FirstState;
5705  if (F.Kind == MK_ImplicitModule) {
5706  // Implicitly-built modules are reused with different diagnostic
5707  // settings. Use the initial diagnostic state from Diag to simulate this
5708  // compilation's diagnostic settings.
5709  FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5710  DiagStates.push_back(FirstState);
5711 
5712  // Skip the initial diagnostic state from the serialized module.
5713  assert(Record[1] == 0 &&
5714  "Invalid data, unexpected backref in initial state");
5715  Idx = 3 + Record[2] * 2;
5716  assert(Idx < Record.size() &&
5717  "Invalid data, not enough state change pairs in initial state");
5718  } else if (F.isModule()) {
5719  // For an explicit module, preserve the flags from the module build
5720  // command line (-w, -Weverything, -Werror, ...) along with any explicit
5721  // -Wblah flags.
5722  unsigned Flags = Record[Idx++];
5723  DiagState Initial;
5724  Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5725  Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5726  Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5727  Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5728  Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5729  Initial.ExtBehavior = (diag::Severity)Flags;
5730  FirstState = ReadDiagState(Initial, SourceLocation(), true);
5731 
5732  // Set up the root buffer of the module to start with the initial
5733  // diagnostic state of the module itself, to cover files that contain no
5734  // explicit transitions (for which we did not serialize anything).
5735  Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5736  .StateTransitions.push_back({FirstState, 0});
5737  } else {
5738  // For prefix ASTs, start with whatever the user configured on the
5739  // command line.
5740  Idx++; // Skip flags.
5741  FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5742  SourceLocation(), false);
5743  }
5744 
5745  // Read the state transitions.
5746  unsigned NumLocations = Record[Idx++];
5747  while (NumLocations--) {
5748  assert(Idx < Record.size() &&
5749  "Invalid data, missing pragma diagnostic states");
5750  SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5751  auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5752  assert(IDAndOffset.second == 0 && "not a start location for a FileID");
5753  unsigned Transitions = Record[Idx++];
5754 
5755  // Note that we don't need to set up Parent/ParentOffset here, because
5756  // we won't be changing the diagnostic state within imported FileIDs
5757  // (other than perhaps appending to the main source file, which has no
5758  // parent).
5759  auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5760  F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5761  for (unsigned I = 0; I != Transitions; ++I) {
5762  unsigned Offset = Record[Idx++];
5763  auto *State =
5764  ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5765  F.StateTransitions.push_back({State, Offset});
5766  }
5767  }
5768 
5769  // Read the final state.
5770  assert(Idx < Record.size() &&
5771  "Invalid data, missing final pragma diagnostic state");
5772  SourceLocation CurStateLoc =
5773  ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5774  auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5775 
5776  if (!F.isModule()) {
5777  Diag.DiagStatesByLoc.CurDiagState = CurState;
5778  Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5779 
5780  // Preserve the property that the imaginary root file describes the
5781  // current state.
5782  FileID NullFile;
5783  auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5784  if (T.empty())
5785  T.push_back({CurState, 0});
5786  else
5787  T[0].State = CurState;
5788  }
5789 
5790  // Don't try to read these mappings again.
5791  Record.clear();
5792  }
5793 }
5794 
5795 /// \brief Get the correct cursor and offset for loading a type.
5796 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5797  GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5798  assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5799  ModuleFile *M = I->second;
5800  return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5801 }
5802 
5803 /// \brief Read and return the type with the given index..
5804 ///
5805 /// The index is the type ID, shifted and minus the number of predefs. This
5806 /// routine actually reads the record corresponding to the type at the given
5807 /// location. It is a helper routine for GetType, which deals with reading type
5808 /// IDs.
5809 QualType ASTReader::readTypeRecord(unsigned Index) {
5810  assert(ContextObj && "reading type with no AST context");
5811  ASTContext &Context = *ContextObj;
5812  RecordLocation Loc = TypeCursorForIndex(Index);
5813  BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5814 
5815  // Keep track of where we are in the stream, then jump back there
5816  // after reading this type.
5817  SavedStreamPosition SavedPosition(DeclsCursor);
5818 
5819  ReadingKindTracker ReadingKind(Read_Type, *this);
5820 
5821  // Note that we are loading a type record.
5822  Deserializing AType(this);
5823 
5824  unsigned Idx = 0;
5825  DeclsCursor.JumpToBit(Loc.Offset);
5826  RecordData Record;
5827  unsigned Code = DeclsCursor.ReadCode();
5828  switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5829  case TYPE_EXT_QUAL: {
5830  if (Record.size() != 2) {
5831  Error("Incorrect encoding of extended qualifier type");
5832  return QualType();
5833  }
5834  QualType Base = readType(*Loc.F, Record, Idx);
5835  Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5836  return Context.getQualifiedType(Base, Quals);
5837  }
5838 
5839  case TYPE_COMPLEX: {
5840  if (Record.size() != 1) {
5841  Error("Incorrect encoding of complex type");
5842  return QualType();
5843  }
5844  QualType ElemType = readType(*Loc.F, Record, Idx);
5845  return Context.getComplexType(ElemType);
5846  }
5847 
5848  case TYPE_POINTER: {
5849  if (Record.size() != 1) {
5850  Error("Incorrect encoding of pointer type");
5851  return QualType();
5852  }
5853  QualType PointeeType = readType(*Loc.F, Record, Idx);
5854  return Context.getPointerType(PointeeType);
5855  }
5856 
5857  case TYPE_DECAYED: {
5858  if (Record.size() != 1) {
5859  Error("Incorrect encoding of decayed type");
5860  return QualType();
5861  }
5862  QualType OriginalType = readType(*Loc.F, Record, Idx);
5863  QualType DT = Context.getAdjustedParameterType(OriginalType);
5864  if (!isa<DecayedType>(DT))
5865  Error("Decayed type does not decay");
5866  return DT;
5867  }
5868 
5869  case TYPE_ADJUSTED: {
5870  if (Record.size() != 2) {
5871  Error("Incorrect encoding of adjusted type");
5872  return QualType();
5873  }
5874  QualType OriginalTy = readType(*Loc.F, Record, Idx);
5875  QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5876  return Context.getAdjustedType(OriginalTy, AdjustedTy);
5877  }
5878 
5879  case TYPE_BLOCK_POINTER: {
5880  if (Record.size() != 1) {
5881  Error("Incorrect encoding of block pointer type");
5882  return QualType();
5883  }
5884  QualType PointeeType = readType(*Loc.F, Record, Idx);
5885  return Context.getBlockPointerType(PointeeType);
5886  }
5887 
5888  case TYPE_LVALUE_REFERENCE: {
5889  if (Record.size() != 2) {
5890  Error("Incorrect encoding of lvalue reference type");
5891  return QualType();
5892  }
5893  QualType PointeeType = readType(*Loc.F, Record, Idx);
5894  return Context.getLValueReferenceType(PointeeType, Record[1]);
5895  }
5896 
5897  case TYPE_RVALUE_REFERENCE: {
5898  if (Record.size() != 1) {
5899  Error("Incorrect encoding of rvalue reference type");
5900  return QualType();
5901  }
5902  QualType PointeeType = readType(*Loc.F, Record, Idx);
5903  return Context.getRValueReferenceType(PointeeType);
5904  }
5905 
5906  case TYPE_MEMBER_POINTER: {
5907  if (Record.size() != 2) {
5908  Error("Incorrect encoding of member pointer type");
5909  return QualType();
5910  }
5911  QualType PointeeType = readType(*Loc.F, Record, Idx);
5912  QualType ClassType = readType(*Loc.F, Record, Idx);
5913  if (PointeeType.isNull() || ClassType.isNull())
5914  return QualType();
5915 
5916  return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5917  }
5918 
5919  case TYPE_CONSTANT_ARRAY: {
5920  QualType ElementType = readType(*Loc.F, Record, Idx);
5922  unsigned IndexTypeQuals = Record[2];
5923  unsigned Idx = 3;
5924  llvm::APInt Size = ReadAPInt(Record, Idx);
5925  return Context.getConstantArrayType(ElementType, Size,
5926  ASM, IndexTypeQuals);
5927  }
5928 
5929  case TYPE_INCOMPLETE_ARRAY: {
5930  QualType ElementType = readType(*Loc.F, Record, Idx);
5932  unsigned IndexTypeQuals = Record[2];
5933  return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5934  }
5935 
5936  case TYPE_VARIABLE_ARRAY: {
5937  QualType ElementType = readType(*Loc.F, Record, Idx);
5939  unsigned IndexTypeQuals = Record[2];
5940  SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5941  SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5942  return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5943  ASM, IndexTypeQuals,
5944  SourceRange(LBLoc, RBLoc));
5945  }
5946 
5947  case TYPE_VECTOR: {
5948  if (Record.size() != 3) {
5949  Error("incorrect encoding of vector type in AST file");
5950  return QualType();
5951  }
5952 
5953  QualType ElementType = readType(*Loc.F, Record, Idx);
5954  unsigned NumElements = Record[1];
5955  unsigned VecKind = Record[2];
5956  return Context.getVectorType(ElementType, NumElements,
5957  (VectorType::VectorKind)VecKind);
5958  }
5959 
5960  case TYPE_EXT_VECTOR: {
5961  if (Record.size() != 3) {
5962  Error("incorrect encoding of extended vector type in AST file");
5963  return QualType();
5964  }
5965 
5966  QualType ElementType = readType(*Loc.F, Record, Idx);
5967  unsigned NumElements = Record[1];
5968  return Context.getExtVectorType(ElementType, NumElements);
5969  }
5970 
5971  case TYPE_FUNCTION_NO_PROTO: {
5972  if (Record.size() != 7) {
5973  Error("incorrect encoding of no-proto function type");
5974  return QualType();
5975  }
5976  QualType ResultType = readType(*Loc.F, Record, Idx);
5977  FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5978  (CallingConv)Record[4], Record[5], Record[6]);
5979  return Context.getFunctionNoProtoType(ResultType, Info);
5980  }
5981 
5982  case TYPE_FUNCTION_PROTO: {
5983  QualType ResultType = readType(*Loc.F, Record, Idx);
5984 
5986  EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5987  /*hasregparm*/ Record[2],
5988  /*regparm*/ Record[3],
5989  static_cast<CallingConv>(Record[4]),
5990  /*produces*/ Record[5],
5991  /*nocallersavedregs*/ Record[6]);
5992 
5993  unsigned Idx = 7;
5994 
5995  EPI.Variadic = Record[Idx++];
5996  EPI.HasTrailingReturn = Record[Idx++];
5997  EPI.TypeQuals = Record[Idx++];
5998  EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5999  SmallVector<QualType, 8> ExceptionStorage;
6000  readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
6001 
6002  unsigned NumParams = Record[Idx++];
6003  SmallVector<QualType, 16> ParamTypes;
6004  for (unsigned I = 0; I != NumParams; ++I)
6005  ParamTypes.push_back(readType(*Loc.F, Record, Idx));
6006 
6008  if (Idx != Record.size()) {
6009  for (unsigned I = 0; I != NumParams; ++I)
6010  ExtParameterInfos.push_back(
6012  ::getFromOpaqueValue(Record[Idx++]));
6013  EPI.ExtParameterInfos = ExtParameterInfos.data();
6014  }
6015 
6016  assert(Idx == Record.size());
6017 
6018  return Context.getFunctionType(ResultType, ParamTypes, EPI);
6019  }
6020 
6021  case TYPE_UNRESOLVED_USING: {
6022  unsigned Idx = 0;
6023  return Context.getTypeDeclType(
6024  ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
6025  }
6026 
6027  case TYPE_TYPEDEF: {
6028  if (Record.size() != 2) {
6029  Error("incorrect encoding of typedef type");
6030  return QualType();
6031  }
6032  unsigned Idx = 0;
6033  TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
6034  QualType Canonical = readType(*Loc.F, Record, Idx);
6035  if (!Canonical.isNull())
6036  Canonical = Context.getCanonicalType(Canonical);
6037  return Context.getTypedefType(Decl, Canonical);
6038  }
6039 
6040  case TYPE_TYPEOF_EXPR:
6041  return Context.getTypeOfExprType(ReadExpr(*Loc.F));
6042 
6043  case TYPE_TYPEOF: {
6044  if (Record.size() != 1) {
6045  Error("incorrect encoding of typeof(type) in AST file");
6046  return QualType();
6047  }
6048  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6049  return Context.getTypeOfType(UnderlyingType);
6050  }
6051 
6052  case TYPE_DECLTYPE: {
6053  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6054  return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
6055  }
6056 
6057  case TYPE_UNARY_TRANSFORM: {
6058  QualType BaseType = readType(*Loc.F, Record, Idx);
6059  QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6061  return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
6062  }
6063 
6064  case TYPE_AUTO: {
6065  QualType Deduced = readType(*Loc.F, Record, Idx);
6066  AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
6067  bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6068  return Context.getAutoType(Deduced, Keyword, IsDependent);
6069  }
6070 
6072  TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6073  QualType Deduced = readType(*Loc.F, Record, Idx);
6074  bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6075  return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6076  IsDependent);
6077  }
6078 
6079  case TYPE_RECORD: {
6080  if (Record.size() != 2) {
6081  Error("incorrect encoding of record type");
6082  return QualType();
6083  }
6084  unsigned Idx = 0;
6085  bool IsDependent = Record[Idx++];
6086  RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6087  RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6088  QualType T = Context.getRecordType(RD);
6089  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6090  return T;
6091  }
6092 
6093  case TYPE_ENUM: {
6094  if (Record.size() != 2) {
6095  Error("incorrect encoding of enum type");
6096  return QualType();
6097  }
6098  unsigned Idx = 0;
6099  bool IsDependent = Record[Idx++];
6100  QualType T
6101  = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6102  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6103  return T;
6104  }
6105 
6106  case TYPE_ATTRIBUTED: {
6107  if (Record.size() != 3) {
6108  Error("incorrect encoding of attributed type");
6109  return QualType();
6110  }
6111  QualType modifiedType = readType(*Loc.F, Record, Idx);
6112  QualType equivalentType = readType(*Loc.F, Record, Idx);
6113  AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6114  return Context.getAttributedType(kind, modifiedType, equivalentType);
6115  }
6116 
6117  case TYPE_PAREN: {
6118  if (Record.size() != 1) {
6119  Error("incorrect encoding of paren type");
6120  return QualType();
6121  }
6122  QualType InnerType = readType(*Loc.F, Record, Idx);
6123  return Context.getParenType(InnerType);
6124  }
6125 
6126  case TYPE_PACK_EXPANSION: {
6127  if (Record.size() != 2) {
6128  Error("incorrect encoding of pack expansion type");
6129  return QualType();
6130  }
6131  QualType Pattern = readType(*Loc.F, Record, Idx);
6132  if (Pattern.isNull())
6133  return QualType();
6134  Optional<unsigned> NumExpansions;
6135  if (Record[1])
6136  NumExpansions = Record[1] - 1;
6137  return Context.getPackExpansionType(Pattern, NumExpansions);
6138  }
6139 
6140  case TYPE_ELABORATED: {
6141  unsigned Idx = 0;
6142  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6143  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6144  QualType NamedType = readType(*Loc.F, Record, Idx);
6145  return Context.getElaboratedType(Keyword, NNS, NamedType);
6146  }
6147 
6148  case TYPE_OBJC_INTERFACE: {
6149  unsigned Idx = 0;
6150  ObjCInterfaceDecl *ItfD
6151  = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6152  return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6153  }
6154 
6155  case TYPE_OBJC_TYPE_PARAM: {
6156  unsigned Idx = 0;
6158  = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6159  unsigned NumProtos = Record[Idx++];
6161  for (unsigned I = 0; I != NumProtos; ++I)
6162  Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6163  return Context.getObjCTypeParamType(Decl, Protos);
6164  }
6165 
6166  case TYPE_OBJC_OBJECT: {
6167  unsigned Idx = 0;
6168  QualType Base = readType(*Loc.F, Record, Idx);
6169  unsigned NumTypeArgs = Record[Idx++];
6170  SmallVector<QualType, 4> TypeArgs;
6171  for (unsigned I = 0; I != NumTypeArgs; ++I)
6172  TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6173  unsigned NumProtos = Record[Idx++];
6175  for (unsigned I = 0; I != NumProtos; ++I)
6176  Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6177  bool IsKindOf = Record[Idx++];
6178  return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6179  }
6180 
6181  case TYPE_OBJC_OBJECT_POINTER: {
6182  unsigned Idx = 0;
6183  QualType Pointee = readType(*Loc.F, Record, Idx);
6184  return Context.getObjCObjectPointerType(Pointee);
6185  }
6186 
6188  unsigned Idx = 0;
6189  QualType Parm = readType(*Loc.F, Record, Idx);
6190  QualType Replacement = readType(*Loc.F, Record, Idx);
6191  return Context.getSubstTemplateTypeParmType(
6192  cast<TemplateTypeParmType>(Parm),
6193  Context.getCanonicalType(Replacement));
6194  }
6195 
6197  unsigned Idx = 0;
6198  QualType Parm = readType(*Loc.F, Record, Idx);
6199  TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6200  return Context.getSubstTemplateTypeParmPackType(
6201  cast<TemplateTypeParmType>(Parm),
6202  ArgPack);
6203  }
6204 
6205  case TYPE_INJECTED_CLASS_NAME: {
6206  CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6207  QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6208  // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6209  // for AST reading, too much interdependencies.
6210  const Type *T = nullptr;
6211  for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6212  if (const Type *Existing = DI->getTypeForDecl()) {
6213  T = Existing;
6214  break;
6215  }
6216  }
6217  if (!T) {
6218  T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6219  for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6220  DI->setTypeForDecl(T);
6221  }
6222  return QualType(T, 0);
6223  }
6224 
6225  case TYPE_TEMPLATE_TYPE_PARM: {
6226  unsigned Idx = 0;
6227  unsigned Depth = Record[Idx++];
6228  unsigned Index = Record[Idx++];
6229  bool Pack = Record[Idx++];
6231  = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6232  return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6233  }
6234 
6235  case TYPE_DEPENDENT_NAME: {
6236  unsigned Idx = 0;
6237  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6238  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6239  const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6240  QualType Canon = readType(*Loc.F, Record, Idx);
6241  if (!Canon.isNull())
6242  Canon = Context.getCanonicalType(Canon);
6243  return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6244  }
6245 
6247  unsigned Idx = 0;
6248  ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6249  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6250  const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6251  unsigned NumArgs = Record[Idx++];
6253  Args.reserve(NumArgs);
6254  while (NumArgs--)
6255  Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6256  return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6257  Args);
6258  }
6259 
6261  unsigned Idx = 0;
6262 
6263  // ArrayType
6264  QualType ElementType = readType(*Loc.F, Record, Idx);
6266  = (ArrayType::ArraySizeModifier)Record[Idx++];
6267  unsigned IndexTypeQuals = Record[Idx++];
6268 
6269  // DependentSizedArrayType
6270  Expr *NumElts = ReadExpr(*Loc.F);
6271  SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6272 
6273  return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6274  IndexTypeQuals, Brackets);
6275  }
6276 
6278  unsigned Idx = 0;
6279  bool IsDependent = Record[Idx++];
6280  TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6282  ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6283  QualType Underlying = readType(*Loc.F, Record, Idx);
6284  QualType T;
6285  if (Underlying.isNull())
6286  T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6287  else
6288  T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6289  const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6290  return T;
6291  }
6292 
6293  case TYPE_ATOMIC: {
6294  if (Record.size() != 1) {
6295  Error("Incorrect encoding of atomic type");
6296  return QualType();
6297  }
6298  QualType ValueType = readType(*Loc.F, Record, Idx);
6299  return Context.getAtomicType(ValueType);
6300  }
6301 
6302  case TYPE_PIPE: {
6303  if (Record.size() != 2) {
6304  Error("Incorrect encoding of pipe type");
6305  return QualType();
6306  }
6307 
6308  // Reading the pipe element type.
6309  QualType ElementType = readType(*Loc.F, Record, Idx);
6310  unsigned ReadOnly = Record[1];
6311  return Context.getPipeType(ElementType, ReadOnly);
6312  }
6313 
6315  unsigned Idx = 0;
6316 
6317  // DependentSizedExtVectorType
6318  QualType ElementType = readType(*Loc.F, Record, Idx);
6319  Expr *SizeExpr = ReadExpr(*Loc.F);
6320  SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6321 
6322  return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6323  AttrLoc);
6324  }
6325 
6327  unsigned Idx = 0;
6328 
6329  // DependentAddressSpaceType
6330  QualType PointeeType = readType(*Loc.F, Record, Idx);
6331  Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
6332  SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6333 
6334  return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
6335  AttrLoc);
6336  }
6337  }
6338  llvm_unreachable("Invalid TypeCode!");
6339 }
6340 
6341 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6342  SmallVectorImpl<QualType> &Exceptions,
6344  const RecordData &Record, unsigned &Idx) {
6346  static_cast<ExceptionSpecificationType>(Record[Idx++]);
6347  ESI.Type = EST;
6348  if (EST == EST_Dynamic) {
6349  for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6350  Exceptions.push_back(readType(ModuleFile, Record, Idx));
6351  ESI.Exceptions = Exceptions;
6352  } else if (EST == EST_ComputedNoexcept) {
6353  ESI.NoexceptExpr = ReadExpr(ModuleFile);
6354  } else if (EST == EST_Uninstantiated) {
6355  ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6356  ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6357  } else if (EST == EST_Unevaluated) {
6358  ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6359  }
6360 }
6361 
6362 namespace clang {
6363 
6364 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6365  ModuleFile *F;
6366  ASTReader *Reader;
6367  const ASTReader::RecordData &Record;
6368  unsigned &Idx;
6369 
6370  SourceLocation ReadSourceLocation() {
6371  return Reader->ReadSourceLocation(*F, Record, Idx);
6372  }
6373 
6374  TypeSourceInfo *GetTypeSourceInfo() {
6375  return Reader->GetTypeSourceInfo(*F, Record, Idx);
6376  }
6377 
6378  NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6379  return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6380  }
6381 
6382 public:
6383  TypeLocReader(ModuleFile &F, ASTReader &Reader,
6384  const ASTReader::RecordData &Record, unsigned &Idx)
6385  : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6386 
6387  // We want compile-time assurance that we've enumerated all of
6388  // these, so unfortunately we have to declare them first, then
6389  // define them out-of-line.
6390 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6391 #define TYPELOC(CLASS, PARENT) \
6392  void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6393 #include "clang/AST/TypeLocNodes.def"
6394 
6395  void VisitFunctionTypeLoc(FunctionTypeLoc);
6396  void VisitArrayTypeLoc(ArrayTypeLoc);
6397 };
6398 
6399 } // namespace clang
6400 
6401 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6402  // nothing to do
6403 }
6404 
6405 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6406  TL.setBuiltinLoc(ReadSourceLocation());
6407  if (TL.needsExtraLocalData()) {
6408  TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6409  TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6410  TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6411  TL.setModeAttr(Record[Idx++]);
6412  }
6413 }
6414 
6415 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6416  TL.setNameLoc(ReadSourceLocation());
6417 }
6418 
6419 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6420  TL.setStarLoc(ReadSourceLocation());
6421 }
6422 
6423 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6424  // nothing to do
6425 }
6426 
6427 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6428  // nothing to do
6429 }
6430 
6431 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6432  TL.setCaretLoc(ReadSourceLocation());
6433 }
6434 
6435 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6436  TL.setAmpLoc(ReadSourceLocation());
6437 }
6438 
6439 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6440  TL.setAmpAmpLoc(ReadSourceLocation());
6441 }
6442 
6443 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6444  TL.setStarLoc(ReadSourceLocation());
6445  TL.setClassTInfo(GetTypeSourceInfo());
6446 }
6447 
6449  TL.setLBracketLoc(ReadSourceLocation());
6450  TL.setRBracketLoc(ReadSourceLocation());
6451  if (Record[Idx++])
6452  TL.setSizeExpr(Reader->ReadExpr(*F));
6453  else
6454  TL.setSizeExpr(nullptr);
6455 }
6456 
6457 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6458  VisitArrayTypeLoc(TL);
6459 }
6460 
6461 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6462  VisitArrayTypeLoc(TL);
6463 }
6464 
6465 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6466  VisitArrayTypeLoc(TL);
6467 }
6468 
6469 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6471  VisitArrayTypeLoc(TL);
6472 }
6473 
6474 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6476 
6477  TL.setAttrNameLoc(ReadSourceLocation());
6478  SourceRange range;
6479  range.setBegin(ReadSourceLocation());
6480  range.setEnd(ReadSourceLocation());
6481  TL.setAttrOperandParensRange(range);
6482  TL.setAttrExprOperand(Reader->ReadExpr(*F));
6483 }
6484 
6485 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6487  TL.setNameLoc(ReadSourceLocation());
6488 }
6489 
6490 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6491  TL.setNameLoc(ReadSourceLocation());
6492 }
6493 
6494 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6495  TL.setNameLoc(ReadSourceLocation());
6496 }
6497 
6499  TL.setLocalRangeBegin(ReadSourceLocation());
6500  TL.setLParenLoc(ReadSourceLocation());
6501  TL.setRParenLoc(ReadSourceLocation());
6502  TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6503  Reader->ReadSourceLocation(*F, Record, Idx)));
6504  TL.setLocalRangeEnd(ReadSourceLocation());
6505  for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6506  TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6507  }
6508 }
6509 
6510 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6511  VisitFunctionTypeLoc(TL);
6512 }
6513 
6514 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6515  VisitFunctionTypeLoc(TL);
6516 }
6517 
6518 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6519  TL.setNameLoc(ReadSourceLocation());
6520 }
6521 
6522 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6523  TL.setNameLoc(ReadSourceLocation());
6524 }
6525 
6526 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6527  TL.setTypeofLoc(ReadSourceLocation());
6528  TL.setLParenLoc(ReadSourceLocation());
6529  TL.setRParenLoc(ReadSourceLocation());
6530 }
6531 
6532 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6533  TL.setTypeofLoc(ReadSourceLocation());
6534  TL.setLParenLoc(ReadSourceLocation());
6535  TL.setRParenLoc(ReadSourceLocation());
6536  TL.setUnderlyingTInfo(GetTypeSourceInfo());
6537 }
6538 
6539 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6540  TL.setNameLoc(ReadSourceLocation());
6541 }
6542 
6543 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6544  TL.setKWLoc(ReadSourceLocation());
6545  TL.setLParenLoc(ReadSourceLocation());
6546  TL.setRParenLoc(ReadSourceLocation());
6547  TL.setUnderlyingTInfo(GetTypeSourceInfo());
6548 }
6549 
6550 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6551  TL.setNameLoc(ReadSourceLocation());
6552 }
6553 
6554 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6556  TL.setTemplateNameLoc(ReadSourceLocation());
6557 }
6558 
6559 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6560  TL.setNameLoc(ReadSourceLocation());
6561 }
6562 
6563 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6564  TL.setNameLoc(ReadSourceLocation());
6565 }
6566 
6567 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6568  TL.setAttrNameLoc(ReadSourceLocation());
6569  if (TL.hasAttrOperand()) {
6570  SourceRange range;
6571  range.setBegin(ReadSourceLocation());
6572  range.setEnd(ReadSourceLocation());
6573  TL.setAttrOperandParensRange(range);
6574  }
6575  if (TL.hasAttrExprOperand()) {
6576  if (Record[Idx++])
6577  TL.setAttrExprOperand(Reader->ReadExpr(*F));
6578  else
6579  TL.setAttrExprOperand(nullptr);
6580  } else if (TL.hasAttrEnumOperand())
6581  TL.setAttrEnumOperandLoc(ReadSourceLocation());
6582 }
6583 
6584 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6585  TL.setNameLoc(ReadSourceLocation());
6586 }
6587 
6588 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6590  TL.setNameLoc(ReadSourceLocation());
6591 }
6592 
6593 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6595  TL.setNameLoc(ReadSourceLocation());
6596 }
6597 
6598 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6600  TL.setTemplateKeywordLoc(ReadSourceLocation());
6601  TL.setTemplateNameLoc(ReadSourceLocation());
6602  TL.setLAngleLoc(ReadSourceLocation());
6603  TL.setRAngleLoc(ReadSourceLocation());
6604  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6605  TL.setArgLocInfo(
6606  i,
6607  Reader->GetTemplateArgumentLocInfo(
6608  *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6609 }
6610 
6611 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6612  TL.setLParenLoc(ReadSourceLocation());
6613  TL.setRParenLoc(ReadSourceLocation());
6614 }
6615 
6616 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6617  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6618  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6619 }
6620 
6621 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6622  TL.setNameLoc(ReadSourceLocation());
6623 }
6624 
6625 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6626  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6627  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6628  TL.setNameLoc(ReadSourceLocation());
6629 }
6630 
6631 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6633  TL.setElaboratedKeywordLoc(ReadSourceLocation());
6634  TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6635  TL.setTemplateKeywordLoc(ReadSourceLocation());
6636  TL.setTemplateNameLoc(ReadSourceLocation());
6637  TL.setLAngleLoc(ReadSourceLocation());
6638  TL.setRAngleLoc(ReadSourceLocation());
6639  for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6640  TL.setArgLocInfo(
6641  I,
6642  Reader->GetTemplateArgumentLocInfo(
6643  *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6644 }
6645 
6646 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6647  TL.setEllipsisLoc(ReadSourceLocation());
6648 }
6649 
6650 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6651  TL.setNameLoc(ReadSourceLocation());
6652 }
6653 
6654 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6655  if (TL.getNumProtocols()) {
6656  TL.setProtocolLAngleLoc(ReadSourceLocation());
6657  TL.setProtocolRAngleLoc(ReadSourceLocation());
6658  }
6659  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6660  TL.setProtocolLoc(i, ReadSourceLocation());
6661 }
6662 
6663 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6664  TL.setHasBaseTypeAsWritten(Record[Idx++]);
6665  TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6666  TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6667  for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6668  TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6669  TL.setProtocolLAngleLoc(ReadSourceLocation());
6670  TL.setProtocolRAngleLoc(ReadSourceLocation());
6671  for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6672  TL.setProtocolLoc(i, ReadSourceLocation());
6673 }
6674 
6675 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6676  TL.setStarLoc(ReadSourceLocation());
6677 }
6678 
6679 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6680  TL.setKWLoc(ReadSourceLocation());
6681  TL.setLParenLoc(ReadSourceLocation());
6682  TL.setRParenLoc(ReadSourceLocation());
6683 }
6684 
6685 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6686  TL.setKWLoc(ReadSourceLocation());
6687 }
6688 
6691  unsigned &Idx) {
6692  QualType InfoTy = readType(F, Record, Idx);
6693  if (InfoTy.isNull())
6694  return nullptr;
6695 
6696  TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6697  TypeLocReader TLR(F, *this, Record, Idx);
6698  for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
6699  TLR.Visit(TL);
6700  return TInfo;
6701 }
6702 
6704  assert(ContextObj && "reading type with no AST context");
6705  ASTContext &Context = *ContextObj;
6706 
6707  unsigned FastQuals = ID & Qualifiers::FastMask;
6708  unsigned Index = ID >> Qualifiers::FastWidth;
6709 
6710  if (Index < NUM_PREDEF_TYPE_IDS) {
6711  QualType T;
6712  switch ((PredefinedTypeIDs)Index) {
6713  case PREDEF_TYPE_NULL_ID:
6714  return QualType();
6715  case PREDEF_TYPE_VOID_ID:
6716  T = Context.VoidTy;
6717  break;
6718  case PREDEF_TYPE_BOOL_ID:
6719  T = Context.BoolTy;
6720  break;
6721  case PREDEF_TYPE_CHAR_U_ID:
6722  case PREDEF_TYPE_CHAR_S_ID:
6723  // FIXME: Check that the signedness of CharTy is correct!
6724  T = Context.CharTy;
6725  break;
6726  case PREDEF_TYPE_UCHAR_ID:
6727  T = Context.UnsignedCharTy;
6728  break;
6729  case PREDEF_TYPE_USHORT_ID:
6730  T = Context.UnsignedShortTy;
6731  break;
6732  case PREDEF_TYPE_UINT_ID:
6733  T = Context.UnsignedIntTy;
6734  break;
6735  case PREDEF_TYPE_ULONG_ID:
6736  T = Context.UnsignedLongTy;
6737  break;
6739  T = Context.UnsignedLongLongTy;
6740  break;
6742  T = Context.UnsignedInt128Ty;
6743  break;
6744  case PREDEF_TYPE_SCHAR_ID:
6745  T = Context.SignedCharTy;
6746  break;
6747  case PREDEF_TYPE_WCHAR_ID:
6748  T = Context.WCharTy;
6749  break;
6750  case PREDEF_TYPE_SHORT_ID:
6751  T = Context.ShortTy;
6752  break;
6753  case PREDEF_TYPE_INT_ID:
6754  T = Context.IntTy;
6755  break;
6756  case PREDEF_TYPE_LONG_ID:
6757  T = Context.LongTy;
6758  break;
6760  T = Context.LongLongTy;
6761  break;
6762  case PREDEF_TYPE_INT128_ID:
6763  T = Context.Int128Ty;
6764  break;
6765  case PREDEF_TYPE_HALF_ID:
6766  T = Context.HalfTy;
6767  break;
6768  case PREDEF_TYPE_FLOAT_ID:
6769  T = Context.FloatTy;
6770  break;
6771  case PREDEF_TYPE_DOUBLE_ID:
6772  T = Context.DoubleTy;
6773  break;
6775  T = Context.LongDoubleTy;
6776  break;
6778  T = Context.Float16Ty;
6779  break;
6781  T = Context.Float128Ty;
6782  break;
6784  T = Context.OverloadTy;
6785  break;
6787  T = Context.BoundMemberTy;
6788  break;
6790  T = Context.PseudoObjectTy;
6791  break;
6793  T = Context.DependentTy;
6794  break;
6796  T = Context.UnknownAnyTy;
6797  break;
6799  T = Context.NullPtrTy;
6800  break;
6801  case PREDEF_TYPE_CHAR16_ID:
6802  T = Context.Char16Ty;
6803  break;
6804  case PREDEF_TYPE_CHAR32_ID:
6805  T = Context.Char32Ty;
6806  break;
6807  case PREDEF_TYPE_OBJC_ID:
6808  T = Context.ObjCBuiltinIdTy;
6809  break;
6811  T = Context.ObjCBuiltinClassTy;
6812  break;
6813  case PREDEF_TYPE_OBJC_SEL:
6814  T = Context.ObjCBuiltinSelTy;
6815  break;
6816 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6817  case PREDEF_TYPE_##Id##_ID: \
6818  T = Context.SingletonId; \
6819  break;
6820 #include "clang/Basic/OpenCLImageTypes.def"
6822  T = Context.OCLSamplerTy;
6823  break;
6824  case PREDEF_TYPE_EVENT_ID:
6825  T = Context.OCLEventTy;
6826  break;
6828  T = Context.OCLClkEventTy;
6829  break;
6830  case PREDEF_TYPE_QUEUE_ID:
6831  T = Context.OCLQueueTy;
6832  break;
6834  T = Context.OCLReserveIDTy;
6835  break;
6837  T = Context.getAutoDeductType();
6838  break;
6840  T = Context.getAutoRRefDeductType();
6841  break;
6843  T = Context.ARCUnbridgedCastTy;
6844  break;
6846  T = Context.BuiltinFnTy;
6847  break;
6849  T = Context.OMPArraySectionTy;
6850  break;
6851  }
6852 
6853  assert(!T.isNull() && "Unknown predefined type");
6854  return T.withFastQualifiers(FastQuals);
6855  }
6856 
6857  Index -= NUM_PREDEF_TYPE_IDS;
6858  assert(Index < TypesLoaded.size() && "Type index out-of-range");
6859  if (TypesLoaded[Index].isNull()) {
6860  TypesLoaded[Index] = readTypeRecord(Index);
6861  if (TypesLoaded[Index].isNull())
6862  return QualType();
6863 
6864  TypesLoaded[Index]->setFromAST();
6865  if (DeserializationListener)
6866  DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
6867  TypesLoaded[Index]);
6868  }
6869 
6870  return TypesLoaded[Index].withFastQualifiers(FastQuals);
6871 }
6872 
6873 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
6874  return GetType(getGlobalTypeID(F, LocalID));
6875 }
6876 
6878 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
6879  unsigned FastQuals = LocalID & Qualifiers::FastMask;
6880  unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
6881 
6882  if (LocalIndex < NUM_PREDEF_TYPE_IDS)
6883  return LocalID;
6884 
6885  if (!F.ModuleOffsetMap.empty())
6886  ReadModuleOffsetMap(F);
6887 
6889  = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
6890  assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
6891 
6892  unsigned GlobalIndex = LocalIndex + I->second;
6893  return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
6894 }
6895 
6899  const RecordData &Record,
6900  unsigned &Index) {
6901  switch (Kind) {
6903  return ReadExpr(F);
6905  return GetTypeSourceInfo(F, Record, Index);
6907  NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6908  Index);
6909  SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6910  return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6911  SourceLocation());
6912  }
6914  NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6915  Index);
6916  SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6917  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6918  return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6919  EllipsisLoc);
6920  }
6926  // FIXME: Is this right?
6927  return TemplateArgumentLocInfo();
6928  }
6929  llvm_unreachable("unexpected template argument loc");
6930 }
6931 
6934  const RecordData &Record, unsigned &Index) {
6935  TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6936 
6937  if (Arg.getKind() == TemplateArgument::Expression) {
6938  if (Record[Index++]) // bool InfoHasSameExpr.
6940  }
6941  return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6942  Record, Index));
6943 }
6944 
6947  const RecordData &Record,
6948  unsigned &Index) {
6949  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6950  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6951  unsigned NumArgsAsWritten = Record[Index++];
6952  TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6953  for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6954  TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6955  return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6956 }
6957 
6959  return GetDecl(ID);
6960 }
6961 
6963  if (NumCurrentElementsDeserializing) {
6964  // We arrange to not care about the complete redeclaration chain while we're
6965  // deserializing. Just remember that the AST has marked this one as complete
6966  // but that it's not actually complete yet, so we know we still need to
6967  // complete it later.
6968  PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6969  return;
6970  }
6971 
6972  const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6973 
6974  // If this is a named declaration, complete it by looking it up
6975  // within its context.
6976  //
6977  // FIXME: Merging a function definition should merge
6978  // all mergeable entities within it.
6979  if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6980  isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6981  if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6982  if (!getContext().getLangOpts().CPlusPlus &&
6983  isa<TranslationUnitDecl>(DC)) {
6984  // Outside of C++, we don't have a lookup table for the TU, so update
6985  // the identifier instead. (For C++ modules, we don't store decls
6986  // in the serialized identifier table, so we do the lookup in the TU.)
6987  auto *II = Name.getAsIdentifierInfo();
6988  assert(II && "non-identifier name in C?");
6989  if (II->isOutOfDate())
6990  updateOutOfDateIdentifier(*II);
6991  } else
6992  DC->lookup(Name);
6993  } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
6994  // Find all declarations of this kind from the relevant context.
6995  for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
6996  auto *DC = cast<DeclContext>(DCDecl);
6997  SmallVector<Decl*, 8> Decls;
6998  FindExternalLexicalDecls(
6999  DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7000  }
7001  }
7002  }
7003 
7004  if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7005  CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7006  if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7007  VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7008  if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7009  if (auto *Template = FD->getPrimaryTemplate())
7010  Template->LoadLazySpecializations();
7011  }
7012 }
7013 
7016  RecordLocation Loc = getLocalBitOffset(Offset);
7017  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7018  SavedStreamPosition SavedPosition(Cursor);
7019  Cursor.JumpToBit(Loc.Offset);
7020  ReadingKindTracker ReadingKind(Read_Decl, *this);
7021 
7022  RecordData Record;
7023  unsigned Code = Cursor.ReadCode();
7024  unsigned RecCode = Cursor.readRecord(Code, Record);
7025  if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
7026  Error("malformed AST file: missing C++ ctor initializers");
7027  return nullptr;
7028  }
7029 
7030  unsigned Idx = 0;
7031  return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
7032 }
7033 
7035  assert(ContextObj && "reading base specifiers with no AST context");
7036  ASTContext &Context = *ContextObj;
7037 
7038  RecordLocation Loc = getLocalBitOffset(Offset);
7039  BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7040  SavedStreamPosition SavedPosition(Cursor);
7041  Cursor.JumpToBit(Loc.Offset);
7042  ReadingKindTracker ReadingKind(Read_Decl, *this);
7043  RecordData Record;
7044  unsigned Code = Cursor.ReadCode();
7045  unsigned RecCode = Cursor.readRecord(Code, Record);
7046  if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7047  Error("malformed AST file: missing C++ base specifiers");
7048  return nullptr;
7049  }
7050 
7051  unsigned Idx = 0;
7052  unsigned NumBases = Record[Idx++];
7053  void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7054  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7055  for (unsigned I = 0; I != NumBases; ++I)
7056  Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
7057  return Bases;
7058 }
7059 
7061 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7062  if (LocalID < NUM_PREDEF_DECL_IDS)
7063  return LocalID;
7064 
7065  if (!F.ModuleOffsetMap.empty())
7066  ReadModuleOffsetMap(F);
7067 
7069  = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7070  assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7071 
7072  return LocalID + I->second;
7073 }
7074 
7076  ModuleFile &M) const {
7077  // Predefined decls aren't from any module.
7078  if (ID < NUM_PREDEF_DECL_IDS)
7079  return false;
7080 
7081  return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7082  ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7083 }
7084 
7085 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7086  if (!D->isFromASTFile())
7087  return nullptr;
7088  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7089  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7090  return I->second;
7091 }
7092 
7094  if (ID < NUM_PREDEF_DECL_IDS)
7095  return SourceLocation();
7096 
7097  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7098 
7099  if (Index > DeclsLoaded.size()) {
7100  Error("declaration ID out-of-range for AST file");
7101  return SourceLocation();
7102  }
7103 
7104  if (Decl *D = DeclsLoaded[Index])
7105  return D->getLocation();
7106 
7107  SourceLocation Loc;
7108  DeclCursorForID(ID, Loc);
7109  return Loc;
7110 }
7111 
7113  switch (ID) {
7114  case PREDEF_DECL_NULL_ID:
7115  return nullptr;
7116 
7118  return Context.getTranslationUnitDecl();
7119 
7121  return Context.getObjCIdDecl();
7122 
7124  return Context.getObjCSelDecl();
7125 
7127  return Context.getObjCClassDecl();
7128 
7130  return Context.getObjCProtocolDecl();
7131 
7133  return Context.getInt128Decl();
7134 
7136  return Context.getUInt128Decl();
7137 
7139  return Context.getObjCInstanceTypeDecl();
7140 
7142  return Context.getBuiltinVaListDecl();
7143 
7145  return Context.getVaListTagDecl();
7146 
7148  return Context.getBuiltinMSVaListDecl();
7149 
7151  return Context.getExternCContextDecl();
7152 
7154  return Context.getMakeIntegerSeqDecl();
7155 
7157  return Context.getCFConstantStringDecl();
7158 
7160  return Context.getCFConstantStringTagDecl();
7161 
7163  return Context.getTypePackElementDecl();
7164  }
7165  llvm_unreachable("PredefinedDeclIDs unknown enum value");
7166 }
7167 
7169  assert(ContextObj && "reading decl with no AST context");
7170  if (ID < NUM_PREDEF_DECL_IDS) {
7171  Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7172  if (D) {
7173  // Track that we have merged the declaration with ID \p ID into the
7174  // pre-existing predefined declaration \p D.
7175  auto &Merged = KeyDecls[D->getCanonicalDecl()];
7176  if (Merged.empty())
7177  Merged.push_back(ID);
7178  }
7179  return D;
7180  }
7181 
7182  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7183 
7184  if (Index >= DeclsLoaded.size()) {
7185  assert(0 && "declaration ID out-of-range for AST file");
7186  Error("declaration ID out-of-range for AST file");
7187  return nullptr;
7188  }
7189 
7190  return DeclsLoaded[Index];
7191 }
7192 
7194  if (ID < NUM_PREDEF_DECL_IDS)
7195  return GetExistingDecl(ID);
7196 
7197  unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7198 
7199  if (Index >= DeclsLoaded.size()) {
7200  assert(0 && "declaration ID out-of-range for AST file");
7201  Error("declaration ID out-of-range for AST file");
7202  return nullptr;
7203  }
7204 
7205  if (!DeclsLoaded[Index]) {
7206  ReadDeclRecord(ID);
7207  if (DeserializationListener)
7208  DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7209  }
7210 
7211  return DeclsLoaded[Index];
7212 }
7213 
7215  DeclID GlobalID) {
7216  if (GlobalID < NUM_PREDEF_DECL_IDS)
7217  return GlobalID;
7218 
7219  GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7220  assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7221  ModuleFile *Owner = I->second;
7222 
7223  llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7224  = M.GlobalToLocalDeclIDs.find(Owner);
7225  if (Pos == M.GlobalToLocalDeclIDs.end())
7226  return 0;
7227 
7228  return GlobalID - Owner->BaseDeclID + Pos->second;
7229 }
7230 
7232  const RecordData &Record,
7233  unsigned &Idx) {
7234  if (Idx >= Record.size()) {
7235  Error("Corrupted AST file");
7236  return 0;
7237  }
7238 
7239  return getGlobalDeclID(F, Record[Idx++]);
7240 }
7241 
7242 /// \brief Resolve the offset of a statement into a statement.
7243 ///
7244 /// This operation will read a new statement from the external
7245 /// source each time it is called, and is meant to be used via a
7246 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7248  // Switch case IDs are per Decl.
7249  ClearSwitchCaseIDs();
7250 
7251  // Offset here is a global offset across the entire chain.
7252  RecordLocation Loc = getLocalBitOffset(Offset);
7253  Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7254  assert(NumCurrentElementsDeserializing == 0 &&
7255  "should not be called while already deserializing");
7256  Deserializing D(this);
7257  return ReadStmtFromStream(*Loc.F);
7258 }
7259 
7261  const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7262  SmallVectorImpl<Decl *> &Decls) {
7263  bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7264 
7265  auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7266  assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7267  for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7268  auto K = (Decl::Kind)+LexicalDecls[I];
7269  if (!IsKindWeWant(K))
7270  continue;
7271 
7272  auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7273 
7274  // Don't add predefined declarations to the lexical context more
7275  // than once.
7276  if (ID < NUM_PREDEF_DECL_IDS) {
7277  if (PredefsVisited[ID])
7278  continue;
7279 
7280  PredefsVisited[ID] = true;
7281  }
7282 
7283  if (Decl *D = GetLocalDecl(*M, ID)) {
7284  assert(D->getKind() == K && "wrong kind for lexical decl");
7285  if (!DC->isDeclInLexicalTraversal(D))
7286  Decls.push_back(D);
7287  }
7288  }
7289  };
7290 
7291  if (isa<TranslationUnitDecl>(DC)) {
7292  for (auto Lexical : TULexicalDecls)
7293  Visit(Lexical.first, Lexical.second);
7294  } else {
7295  auto I = LexicalDecls.find(DC);
7296  if (I != LexicalDecls.end())
7297  Visit(I->second.first, I->second.second);
7298  }
7299 
7300  ++NumLexicalDeclContextsRead;
7301 }
7302 
7303 namespace {
7304 
7305 class DeclIDComp {
7306  ASTReader &Reader;
7307  ModuleFile &Mod;
7308 
7309 public:
7310  DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7311 
7312  bool operator()(LocalDeclID L, LocalDeclID R) const {
7313  SourceLocation LHS = getLocation(L);
7314  SourceLocation RHS = getLocation(R);
7315  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7316  }
7317 
7318  bool operator()(SourceLocation LHS, LocalDeclID R) const {
7319  SourceLocation RHS = getLocation(R);
7320  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7321  }
7322 
7323  bool operator()(LocalDeclID L, SourceLocation RHS) const {
7324  SourceLocation LHS = getLocation(L);
7325  return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7326  }
7327 
7328  SourceLocation getLocation(LocalDeclID ID) const {
7329  return Reader.getSourceManager().getFileLoc(
7330  Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7331  }
7332 };
7333 
7334 } // namespace
7335 
7337  unsigned Offset, unsigned Length,
7338  SmallVectorImpl<Decl *> &Decls) {
7339  SourceManager &SM = getSourceManager();
7340 
7341  llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7342  if (I == FileDeclIDs.end())
7343  return;
7344 
7345  FileDeclsInfo &DInfo = I->second;
7346  if (DInfo.Decls.empty())
7347  return;
7348 
7350  BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7351  SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7352 
7353  DeclIDComp DIDComp(*this, *DInfo.Mod);
7355  BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7356  BeginLoc, DIDComp);
7357  if (BeginIt != DInfo.Decls.begin())
7358  --BeginIt;
7359 
7360  // If we are pointing at a top-level decl inside an objc container, we need
7361  // to backtrack until we find it otherwise we will fail to report that the
7362  // region overlaps with an objc container.
7363  while (BeginIt != DInfo.Decls.begin() &&
7364  GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7365  ->isTopLevelDeclInObjCContainer())
7366  --BeginIt;
7367 
7369  EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7370  EndLoc, DIDComp);
7371  if (EndIt != DInfo.Decls.end())
7372  ++EndIt;
7373 
7375  DIt = BeginIt; DIt != EndIt; ++DIt)
7376  Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7377 }
7378 
7379 bool
7381  DeclarationName Name) {
7382  assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7383  "DeclContext has no visible decls in storage");
7384  if (!Name)
7385  return false;
7386 
7387  auto It = Lookups.find(DC);
7388  if (It == Lookups.end())
7389  return false;
7390 
7391  Deserializing LookupResults(this);
7392 
7393  // Load the list of declarations.
7395  for (DeclID ID : It->second.Table.find(Name)) {
7396  NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7397  if (ND->getDeclName() == Name)
7398  Decls.push_back(ND);
7399  }
7400 
7401  ++NumVisibleDeclContextsRead;
7402  SetExternalVisibleDeclsForName(DC, Name, Decls);
7403  return !Decls.empty();
7404 }
7405 
7407  if (!DC->hasExternalVisibleStorage())
7408  return;
7409 
7410  auto It = Lookups.find(DC);
7411  assert(It != Lookups.end() &&
7412  "have external visible storage but no lookup tables");
7413 
7414  DeclsMap Decls;
7415 
7416  for (DeclID ID : It->second.Table.findAll()) {
7417  NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7418  Decls[ND->getDeclName()].push_back(ND);
7419  }
7420 
7421  ++NumVisibleDeclContextsRead;
7422 
7423  for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7424  SetExternalVisibleDeclsForName(DC, I->first, I->second);
7425  }
7426  const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7427 }
7428 
7431  auto I = Lookups.find(Primary);
7432  return I == Lookups.end() ? nullptr : &I->second;
7433 }
7434 
7435 /// \brief Under non-PCH compilation the consumer receives the objc methods
7436 /// before receiving the implementation, and codegen depends on this.
7437 /// We simulate this by deserializing and passing to consumer the methods of the
7438 /// implementation before passing the deserialized implementation decl.
7440  ASTConsumer *Consumer) {
7441  assert(ImplD && Consumer);
7442 
7443  for (auto *I : ImplD->methods())
7444  Consumer->HandleInterestingDecl(DeclGroupRef(I));
7445 
7446  Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7447 }
7448 
7449 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7450  if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7451  PassObjCImplDeclToConsumer(ImplD, Consumer);
7452  else
7453  Consumer->HandleInterestingDecl(DeclGroupRef(D));
7454 }
7455 
7457  this->Consumer = Consumer;
7458 
7459  if (Consumer)
7460  PassInterestingDeclsToConsumer();
7461 
7462  if (DeserializationListener)
7463  DeserializationListener->ReaderInitialized(this);
7464 }
7465 
7467  std::fprintf(stderr, "*** AST File Statistics:\n");
7468 
7469  unsigned NumTypesLoaded
7470  = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7471  QualType());
7472  unsigned NumDeclsLoaded
7473  = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7474  (Decl *)nullptr);
7475  unsigned NumIdentifiersLoaded
7476  = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7477  IdentifiersLoaded.end(),
7478  (IdentifierInfo *)nullptr);
7479  unsigned NumMacrosLoaded
7480  = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7481  MacrosLoaded.end(),
7482  (MacroInfo *)nullptr);
7483  unsigned NumSelectorsLoaded
7484  = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7485  SelectorsLoaded.end(),
7486  Selector());
7487 
7488  if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7489  std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7490  NumSLocEntriesRead, TotalNumSLocEntries,
7491  ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7492  if (!TypesLoaded.empty())
7493  std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7494  NumTypesLoaded, (unsigned)TypesLoaded.size(),
7495  ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7496  if (!DeclsLoaded.empty())
7497  std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7498  NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7499  ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7500  if (!IdentifiersLoaded.empty())
7501  std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7502  NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7503  ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7504  if (!MacrosLoaded.empty())
7505  std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7506  NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7507  ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7508  if (!SelectorsLoaded.empty())
7509  std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7510  NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7511  ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7512  if (TotalNumStatements)
7513  std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7514  NumStatementsRead, TotalNumStatements,
7515  ((float)NumStatementsRead/TotalNumStatements * 100));
7516  if (TotalNumMacros)
7517  std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7518  NumMacrosRead, TotalNumMacros,
7519  ((float)NumMacrosRead/TotalNumMacros * 100));
7520  if (TotalLexicalDeclContexts)
7521  std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7522  NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7523  ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7524  * 100));
7525  if (TotalVisibleDeclContexts)
7526  std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7527  NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7528  ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7529  * 100));
7530  if (TotalNumMethodPoolEntries)
7531  std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7532  NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7533  ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7534  * 100));
7535  if (NumMethodPoolLookups)
7536  std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7537  NumMethodPoolHits, NumMethodPoolLookups,
7538  ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7539  if (NumMethodPoolTableLookups)
7540  std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7541  NumMethodPoolTableHits, NumMethodPoolTableLookups,
7542  ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7543  * 100.0));
7544  if (NumIdentifierLookupHits)
7545  std::fprintf(stderr,
7546  " %u / %u identifier table lookups succeeded (%f%%)\n",
7547  NumIdentifierLookupHits, NumIdentifierLookups,
7548  (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7549 
7550  if (GlobalIndex) {
7551  std::fprintf(stderr, "\n");
7552  GlobalIndex->printStats();
7553  }
7554 
7555  std::fprintf(stderr, "\n");
7556  dump();
7557  std::fprintf(stderr, "\n");
7558 }
7559 
7560 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7561 LLVM_DUMP_METHOD static void
7562 dumpModuleIDMap(StringRef Name,
7563  const ContinuousRangeMap<Key, ModuleFile *,
7564  InitialCapacity> &Map) {
7565  if (Map.begin() == Map.end())
7566  return;
7567 
7569 
7570  llvm::errs() << Name << ":\n";
7571  for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7572  I != IEnd; ++I) {
7573  llvm::errs() << " " << I->first << " -> " << I->second->FileName
7574  << "\n";
7575  }
7576 }
7577 
7578 LLVM_DUMP_METHOD void ASTReader::dump() {
7579  llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7580  dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7581  dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7582  dumpModuleIDMap("Global type map", GlobalTypeMap);
7583  dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7584  dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7585  dumpModuleIDMap("Global macro map", GlobalMacroMap);
7586  dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7587  dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7588  dumpModuleIDMap("Global preprocessed entity map",
7589  GlobalPreprocessedEntityMap);
7590 
7591  llvm::errs() << "\n*** PCH/Modules Loaded:";
7592  for (ModuleFile &M : ModuleMgr)
7593  M.dump();
7594 }
7595 
7596 /// Return the amount of memory used by memory buffers, breaking down
7597 /// by heap-backed versus mmap'ed memory.
7599  for (ModuleFile &I : ModuleMgr) {
7600  if (llvm::MemoryBuffer *buf = I.Buffer) {
7601  size_t bytes = buf->getBufferSize();
7602  switch (buf->getBufferKind()) {
7603  case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7604  sizes.malloc_bytes += bytes;
7605  break;
7606  case llvm::MemoryBuffer::MemoryBuffer_MMap:
7607  sizes.mmap_bytes += bytes;
7608  break;
7609  }
7610  }
7611  }
7612 }
7613 
7615  SemaObj = &S;
7616  S.addExternalSource(this);
7617 
7618  // Makes sure any declarations that were deserialized "too early"
7619  // still get added to the identifier's declaration chains.
7620  for (uint64_t ID : PreloadedDeclIDs) {
7621  NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7622  pushExternalDeclIntoScope(D, D->getDeclName());
7623  }
7624  PreloadedDeclIDs.clear();
7625 
7626  // FIXME: What happens if these are changed by a module import?
7627  if (!FPPragmaOptions.empty()) {
7628  assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7629  SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7630  }
7631 
7632  SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7633  SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7634  SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7635 
7636  UpdateSema();
7637 }
7638 
7640  assert(SemaObj && "no Sema to update");
7641 
7642  // Load the offsets of the declarations that Sema references.
7643  // They will be lazily deserialized when needed.
7644  if (!SemaDeclRefs.empty()) {
7645  assert(SemaDeclRefs.size() % 3 == 0);
7646  for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7647  if (!SemaObj->StdNamespace)
7648  SemaObj->StdNamespace = SemaDeclRefs[I];
7649  if (!SemaObj->StdBadAlloc)
7650  SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7651  if (!SemaObj->StdAlignValT)
7652  SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7653  }
7654  SemaDeclRefs.clear();
7655  }
7656 
7657  // Update the state of pragmas. Use the same API as if we had encountered the
7658  // pragma in the source.
7659  if(OptimizeOffPragmaLocation.isValid())
7660  SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7661  if (PragmaMSStructState != -1)
7662  SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7663  if (PointersToMembersPragmaLocation.isValid()) {
7664  SemaObj->ActOnPragmaMSPointersToMembers(
7666  PragmaMSPointersToMembersState,
7667  PointersToMembersPragmaLocation);
7668  }
7669  SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7670 
7671  if (PragmaPackCurrentValue) {
7672  // The bottom of the stack might have a default value. It must be adjusted
7673  // to the current value to ensure that the packing state is preserved after
7674  // popping entries that were included/imported from a PCH/module.
7675  bool DropFirst = false;
7676  if (!PragmaPackStack.empty() &&
7677  PragmaPackStack.front().Location.isInvalid()) {
7678  assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7679  "Expected a default alignment value");
7680  SemaObj->PackStack.Stack.emplace_back(
7681  PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7682  SemaObj->PackStack.CurrentPragmaLocation,
7683  PragmaPackStack.front().PushLocation);
7684  DropFirst = true;
7685  }
7686  for (const auto &Entry :
7687  llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7688  SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7689  Entry.Location, Entry.PushLocation);
7690  if (PragmaPackCurrentLocation.isInvalid()) {
7691  assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7692  "Expected a default alignment value");
7693  // Keep the current values.
7694  } else {
7695  SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7696  SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7697  }
7698  }
7699 }
7700 
7701 IdentifierInfo *ASTReader::get(StringRef Name) {
7702  // Note that we are loading an identifier.
7703  Deserializing AnIdentifier(this);
7704 
7705  IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7706  NumIdentifierLookups,
7707  NumIdentifierLookupHits);
7708 
7709  // We don't need to do identifier table lookups in C++ modules (we preload
7710  // all interesting declarations, and don't need to use the scope for name
7711  // lookups). Perform the lookup in PCH files, though, since we don't build
7712  // a complete initial identifier table if we're carrying on from a PCH.
7713  if (PP.getLangOpts().CPlusPlus) {
7714  for (auto F : ModuleMgr.pch_modules())
7715  if (Visitor(*F))
7716  break;
7717  } else {
7718  // If there is a global index, look there first to determine which modules
7719  // provably do not have any results for this identifier.
7721  GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7722  if (!loadGlobalIndex()) {
7723  if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7724  HitsPtr = &Hits;
7725  }
7726  }
7727 
7728  ModuleMgr.visit(Visitor, HitsPtr);
7729  }
7730 
7731  IdentifierInfo *II = Visitor.getIdentifierInfo();
7732  markIdentifierUpToDate(II);
7733  return II;
7734 }
7735 
7736 namespace clang {
7737 
7738  /// \brief An identifier-lookup iterator that enumerates all of the
7739  /// identifiers stored within a set of AST files.
7741  /// \brief The AST reader whose identifiers are being enumerated.
7742  const ASTReader &Reader;
7743 
7744  /// \brief The current index into the chain of AST files stored in
7745  /// the AST reader.
7746  unsigned Index;
7747 
7748  /// \brief The current position within the identifier lookup table
7749  /// of the current AST file.
7750  ASTIdentifierLookupTable::key_iterator Current;
7751 
7752  /// \brief The end position within the identifier lookup table of
7753  /// the current AST file.
7754  ASTIdentifierLookupTable::key_iterator End;
7755 
7756  /// \brief Whether to skip any modules in the ASTReader.
7757  bool SkipModules;
7758 
7759  public:
7760  explicit ASTIdentifierIterator(const ASTReader &Reader,
7761  bool SkipModules = false);
7762 
7763  StringRef Next() override;
7764  };
7765 
7766 } // namespace clang
7767 
7769  bool SkipModules)
7770  : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7771 }
7772 
7774  while (Current == End) {
7775  // If we have exhausted all of our AST files, we're done.
7776  if (Index == 0)
7777  return StringRef();
7778 
7779  --Index;
7780  ModuleFile &F = Reader.ModuleMgr[Index];
7781  if (SkipModules && F.isModule())
7782  continue;
7783 
7784  ASTIdentifierLookupTable *IdTable =
7786  Current = IdTable->key_begin();
7787  End = IdTable->key_end();
7788  }
7789 
7790  // We have any identifiers remaining in the current AST file; return
7791  // the next one.
7792  StringRef Result = *Current;
7793  ++Current;
7794  return Result;
7795 }
7796 
7797 namespace {
7798 
7799 /// A utility for appending two IdentifierIterators.
7800 class ChainedIdentifierIterator : public IdentifierIterator {
7801  std::unique_ptr<IdentifierIterator> Current;
7802  std::unique_ptr<IdentifierIterator> Queued;
7803 
7804 public:
7805  ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7806  std::unique_ptr<IdentifierIterator> Second)
7807  : Current(std::move(First)), Queued(std::move(Second)) {}
7808 
7809  StringRef Next() override {
7810  if (!Current)
7811  return StringRef();
7812 
7813  StringRef result = Current->Next();
7814  if (!result.empty())
7815  return result;
7816 
7817  // Try the queued iterator, which may itself be empty.
7818  Current.reset();
7819  std::swap(Current, Queued);
7820  return Next();
7821  }
7822 };
7823 
7824 } // namespace
7825 
7827  if (!loadGlobalIndex()) {
7828  std::unique_ptr<IdentifierIterator> ReaderIter(
7829  new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7830  std::unique_ptr<IdentifierIterator> ModulesIter(
7831  GlobalIndex->createIdentifierIterator());
7832  return new ChainedIdentifierIterator(std::move(ReaderIter),
7833  std::move(ModulesIter));
7834  }
7835 
7836  return new ASTIdentifierIterator(*this);
7837 }
7838 
7839 namespace clang {
7840 namespace serialization {
7841 
7843  ASTReader &Reader;
7844  Selector Sel;
7845  unsigned PriorGeneration;
7846  unsigned InstanceBits = 0;
7847  unsigned FactoryBits = 0;
7848  bool InstanceHasMoreThanOneDecl = false;
7849  bool FactoryHasMoreThanOneDecl = false;
7850  SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7851  SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
7852 
7853  public:
7855  unsigned PriorGeneration)
7856  : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
7857 
7858  bool operator()(ModuleFile &M) {
7859  if (!M.SelectorLookupTable)
7860  return false;
7861 
7862  // If we've already searched this module file, skip it now.
7863  if (M.Generation <= PriorGeneration)
7864  return true;
7865 
7866  ++Reader.NumMethodPoolTableLookups;
7867  ASTSelectorLookupTable *PoolTable
7869  ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
7870  if (Pos == PoolTable->end())
7871  return false;
7872 
7873  ++Reader.NumMethodPoolTableHits;
7874  ++Reader.NumSelectorsRead;
7875  // FIXME: Not quite happy with the statistics here. We probably should
7876  // disable this tracking when called via LoadSelector.
7877  // Also, should entries without methods count as misses?
7878  ++Reader.NumMethodPoolEntriesRead;
7880  if (Reader.DeserializationListener)
7881  Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
7882 
7883  InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7884  FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7885  InstanceBits = Data.InstanceBits;
7886  FactoryBits = Data.FactoryBits;
7887  InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
7888  FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
7889  return true;
7890  }
7891 
7892  /// \brief Retrieve the instance methods found by this visitor.
7894  return InstanceMethods;
7895  }
7896 
7897  /// \brief Retrieve the instance methods found by this visitor.
7899  return FactoryMethods;
7900  }
7901 
7902  unsigned getInstanceBits() const { return InstanceBits; }
7903  unsigned getFactoryBits() const { return FactoryBits; }
7904 
7906  return InstanceHasMoreThanOneDecl;
7907  }
7908 
7909  bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
7910  };
7911 
7912 } // namespace serialization
7913 } // namespace clang
7914 
7915 /// \brief Add the given set of methods to the method list.
7917  ObjCMethodList &List) {
7918  for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7919  S.addMethodToGlobalList(&List, Methods[I]);
7920  }
7921 }
7922 
7924  // Get the selector generation and update it to the current generation.
7925  unsigned &Generation = SelectorGeneration[Sel];
7926  unsigned PriorGeneration = Generation;
7927  Generation = getGeneration();
7928  SelectorOutOfDate[Sel] = false;
7929 
7930  // Search for methods defined with this selector.
7931  ++NumMethodPoolLookups;
7932  ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
7933  ModuleMgr.visit(Visitor);
7934 
7935  if (Visitor.getInstanceMethods().empty() &&
7936  Visitor.getFactoryMethods().empty())
7937  return;
7938 
7939  ++NumMethodPoolHits;
7940 
7941  if (!getSema())
7942  return;
7943 
7944  Sema &S = *getSema();
7945  Sema::GlobalMethodPool::iterator Pos
7946  = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
7947 
7948  Pos->second.first.setBits(Visitor.getInstanceBits());
7949  Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
7950  Pos->second.second.setBits(Visitor.getFactoryBits());
7951  Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
7952 
7953  // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
7954  // when building a module we keep every method individually and may need to
7955  // update hasMoreThanOneDecl as we add the methods.
7956  addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7957  addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
7958 }
7959 
7961  if (SelectorOutOfDate[Sel])
7962  ReadMethodPool(Sel);
7963 }
7964 
7966  SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7967  Namespaces.clear();
7968 
7969  for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7970  if (NamespaceDecl *Namespace
7971  = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7972  Namespaces.push_back(Namespace);
7973  }
7974 }
7975 
7977  llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
7978  for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7979  NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
7980  SourceLocation Loc =
7981  SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
7982  Undefined.insert(std::make_pair(D, Loc));
7983  }
7984 }
7985 
7987  FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
7988  Exprs) {
7989  for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
7990  FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
7991  uint64_t Count = DelayedDeleteExprs[Idx++];
7992  for (uint64_t C = 0; C < Count; ++C) {
7993  SourceLocation DeleteLoc =
7994  SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
7995  const bool IsArrayForm = DelayedDeleteExprs[Idx++];
7996  Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
7997  }
7998  }
7999 }
8000 
8002  SmallVectorImpl<VarDecl *> &TentativeDefs) {
8003  for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8004  VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8005  if (Var)
8006  TentativeDefs.push_back(Var);
8007  }
8008  TentativeDefinitions.clear();
8009 }
8010 
8013  for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8014  DeclaratorDecl *D
8015  = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8016  if (D)
8017  Decls.push_back(D);
8018  }
8019  UnusedFileScopedDecls.clear();
8020 }
8021 
8024  for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8026  = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8027  if (D)
8028  Decls.push_back(D);
8029  }
8030  DelegatingCtorDecls.clear();
8031 }
8032 
8034  for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8035  TypedefNameDecl *D
8036  = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8037  if (D)
8038  Decls.push_back(D);
8039  }
8040  ExtVectorDecls.clear();
8041 }
8042 
8045  for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8046  ++I) {
8047  TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8048  GetDecl(UnusedLocalTypedefNameCandidates[I]));
8049  if (D)
8050  Decls.insert(D);
8051  }
8052  UnusedLocalTypedefNameCandidates.clear();
8053 }
8054 
8056  SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8057  if (ReferencedSelectorsData.empty())
8058  return;
8059 
8060  // If there are @selector references added them to its pool. This is for
8061  // implementation of -Wselector.
8062  unsigned int DataSize = ReferencedSelectorsData.size()-1;
8063  unsigned I = 0;
8064  while (I < DataSize) {
8065  Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8066  SourceLocation SelLoc
8067  = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8068  Sels.push_back(std::make_pair(Sel, SelLoc));
8069  }
8070  ReferencedSelectorsData.clear();
8071 }
8072 
8074  SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8075  if (WeakUndeclaredIdentifiers.empty())
8076  return;
8077 
8078  for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8079  IdentifierInfo *WeakId
8080  = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8081  IdentifierInfo *AliasId
8082  = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8083  SourceLocation Loc
8084  = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8085  bool Used = WeakUndeclaredIdentifiers[I++];
8086  WeakInfo WI(AliasId, Loc);
8087  WI.setUsed(Used);
8088  WeakIDs.push_back(std::make_pair(WeakId, WI));
8089  }
8090  WeakUndeclaredIdentifiers.clear();
8091 }
8092 
8094  for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8095  ExternalVTableUse VT;
8096  VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8097  VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8098  VT.DefinitionRequired = VTableUses[Idx++];
8099  VTables.push_back(VT);
8100  }
8101 
8102  VTableUses.clear();
8103 }
8104 
8106  SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8107  for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8108  ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8109  SourceLocation Loc
8110  = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8111 
8112  Pending.push_back(std::make_pair(D, Loc));
8113  }
8114  PendingInstantiations.clear();
8115 }
8116 
8118  llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8119  &LPTMap) {
8120  for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8121  /* In loop */) {
8122  FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8123 
8124  auto LT = llvm::make_unique<LateParsedTemplate>();
8125  LT->D = GetDecl(LateParsedTemplates[Idx++]);
8126 
8127  ModuleFile *F = getOwningModuleFile(LT->D);
8128  assert(F && "No module");
8129 
8130  unsigned TokN = LateParsedTemplates[Idx++];
8131  LT->Toks.reserve(TokN);
8132  for (unsigned T = 0; T < TokN; ++T)
8133  LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8134 
8135  LPTMap.insert(std::make_pair(FD, std::move(LT)));
8136  }
8137 
8138  LateParsedTemplates.clear();
8139 }
8140 
8142  // It would be complicated to avoid reading the methods anyway. So don't.
8143  ReadMethodPool(Sel);
8144 }
8145 
8147  assert(ID && "Non-zero identifier ID required");
8148  assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8149  IdentifiersLoaded[ID - 1] = II;
8150  if (DeserializationListener)
8151  DeserializationListener->IdentifierRead(ID, II);
8152 }
8153 
8154 /// \brief Set the globally-visible declarations associated with the given
8155 /// identifier.
8156 ///
8157 /// If the AST reader is currently in a state where the given declaration IDs
8158 /// cannot safely be resolved, they are queued until it is safe to resolve
8159 /// them.
8160 ///
8161 /// \param II an IdentifierInfo that refers to one or more globally-visible
8162 /// declarations.
8163 ///
8164 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8165 /// visible at global scope.
8166 ///
8167 /// \param Decls if non-null, this vector will be populated with the set of
8168 /// deserialized declarations. These declarations will not be pushed into
8169 /// scope.
8170 void
8172  const SmallVectorImpl<uint32_t> &DeclIDs,
8173  SmallVectorImpl<Decl *> *Decls) {
8174  if (NumCurrentElementsDeserializing && !Decls) {
8175  PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8176  return;
8177  }
8178 
8179  for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8180  if (!SemaObj) {
8181  // Queue this declaration so that it will be added to the
8182  // translation unit scope and identifier's declaration chain
8183  // once a Sema object is known.
8184  PreloadedDeclIDs.push_back(DeclIDs[I]);
8185  continue;
8186  }
8187 
8188  NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8189 
8190  // If we're simply supposed to record the declarations, do so now.
8191  if (Decls) {
8192  Decls->push_back(D);
8193  continue;
8194  }
8195 
8196  // Introduce this declaration into the translation-unit scope
8197  // and add it to the declaration chain for this identifier, so
8198  // that (unqualified) name lookup will find it.
8199  pushExternalDeclIntoScope(D, II);
8200  }
8201 }
8202 
8204  if (ID == 0)
8205  return nullptr;
8206 
8207  if (IdentifiersLoaded.empty()) {
8208  Error("no identifier table in AST file");
8209  return nullptr;
8210  }
8211 
8212  ID -= 1;
8213  if (!IdentifiersLoaded[ID]) {
8214  GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8215  assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8216  ModuleFile *M = I->second;
8217  unsigned Index = ID - M->BaseIdentifierID;
8218  const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8219 
8220  // All of the strings in the AST file are preceded by a 16-bit length.
8221  // Extract that 16-bit length to avoid having to execute strlen().
8222  // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8223  // unsigned integers. This is important to avoid integer overflow when
8224  // we cast them to 'unsigned'.
8225  const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8226  unsigned StrLen = (((unsigned) StrLenPtr[0])
8227  | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8228  auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8229  IdentifiersLoaded[ID] = &II;
8230  markIdentifierFromAST(*this, II);
8231  if (DeserializationListener)
8232  DeserializationListener->IdentifierRead(ID + 1, &II);
8233  }
8234 
8235  return IdentifiersLoaded[ID];
8236 }
8237 
8238 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8239  return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8240 }
8241 
8242 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8243  if (LocalID < NUM_PREDEF_IDENT_IDS)
8244  return LocalID;
8245 
8246  if (!M.ModuleOffsetMap.empty())
8247  ReadModuleOffsetMap(M);
8248 
8250  = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8251  assert(I != M.IdentifierRemap.end()
8252  && "Invalid index into identifier index remap");
8253 
8254  return LocalID + I->second;
8255 }
8256 
8258  if (ID == 0)
8259  return nullptr;
8260 
8261  if (MacrosLoaded.empty()) {
8262  Error("no macro table in AST file");
8263  return nullptr;
8264  }
8265 
8266  ID -= NUM_PREDEF_MACRO_IDS;
8267  if (!MacrosLoaded[ID]) {
8269  = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8270  assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8271  ModuleFile *M = I->second;
8272  unsigned Index = ID - M->BaseMacroID;
8273  MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8274 
8275  if (DeserializationListener)
8276  DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8277  MacrosLoaded[ID]);
8278  }
8279 
8280  return MacrosLoaded[ID];
8281 }
8282 
8283 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8284  if (LocalID < NUM_PREDEF_MACRO_IDS)
8285  return LocalID;
8286 
8287  if (!M.ModuleOffsetMap.empty())
8288  ReadModuleOffsetMap(M);
8289 
8291  = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8292  assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8293 
8294  return LocalID + I->second;
8295 }
8296 
8298 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8299  if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8300  return LocalID;
8301 
8302  if (!M.ModuleOffsetMap.empty())
8303  ReadModuleOffsetMap(M);
8304 
8307  assert(I != M.SubmoduleRemap.end()
8308  && "Invalid index into submodule index remap");
8309 
8310  return LocalID + I->second;
8311 }
8312 
8314  if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8315  assert(GlobalID == 0 && "Unhandled global submodule ID");
8316  return nullptr;
8317  }
8318 
8319  if (GlobalID > SubmodulesLoaded.size()) {
8320  Error("submodule ID out of range in AST file");
8321  return nullptr;
8322  }
8323 
8324  return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8325 }
8326 
8328  return getSubmodule(ID);
8329 }
8330 
8331 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8332  if (ID & 1) {
8333  // It's a module, look it up by submodule ID.
8334  auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8335  return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8336  } else {
8337  // It's a prefix (preamble, PCH, ...). Look it up by index.
8338  unsigned IndexFromEnd = ID >> 1;
8339  assert(IndexFromEnd && "got reference to unknown module file");
8340  return getModuleManager().pch_modules().end()[-IndexFromEnd];
8341  }
8342 }
8343 
8344 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8345  if (!F)
8346  return 1;
8347 
8348  // For a file representing a module, use the submodule ID of the top-level
8349  // module as the file ID. For any other kind of file, the number of such
8350  // files loaded beforehand will be the same on reload.
8351  // FIXME: Is this true even if we have an explicit module file and a PCH?
8352  if (F->isModule())
8353  return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8354 
8355  auto PCHModules = getModuleManager().pch_modules();
8356  auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
8357  assert(I != PCHModules.end() && "emitting reference to unknown file");
8358  return (I - PCHModules.end()) << 1;
8359 }
8360 
8363  if (const Module *M = getSubmodule(ID))
8365 
8366  // If there is only a single PCH, return it instead.
8367  // Chained PCH are not supported.
8368  const auto &PCHChain = ModuleMgr.pch_modules();
8369  if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8370  ModuleFile &MF = ModuleMgr.getPrimaryModule();
8371  StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8372  StringRef FileName = llvm::sys::path::filename(MF.FileName);
8373  return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8374  MF.Signature);
8375  }
8376  return None;
8377 }
8378 
8380  auto I = DefinitionSource.find(FD);
8381  if (I == DefinitionSource.end())
8382  return EK_ReplyHazy;
8383  return I->second ? EK_Never : EK_Always;
8384 }
8385 
8386 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8387  return DecodeSelector(getGlobalSelectorID(M, LocalID));
8388 }
8389 
8391  if (ID == 0)
8392  return Selector();
8393 
8394  if (ID > SelectorsLoaded.size()) {
8395  Error("selector ID out of range in AST file");
8396  return Selector();
8397  }
8398 
8399  if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8400  // Load this selector from the selector table.
8401  GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8402  assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8403  ModuleFile &M = *I->second;
8404  ASTSelectorLookupTrait Trait(*this, M);
8405  unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8406  SelectorsLoaded[ID - 1] =
8407  Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8408  if (DeserializationListener)
8409  DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8410  }
8411 
8412  return SelectorsLoaded[ID - 1];
8413 }
8414 
8416  return DecodeSelector(ID);
8417 }
8418 
8420  // ID 0 (the null selector) is considered an external selector.
8421  return getTotalNumSelectors() + 1;
8422 }
8423 
8425 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8426  if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8427  return LocalID;
8428 
8429  if (!M.ModuleOffsetMap.empty())
8430  ReadModuleOffsetMap(M);
8431 
8434  assert(I != M.SelectorRemap.end()
8435  && "Invalid index into selector index remap");
8436 
8437  return LocalID + I->second;
8438 }
8439 
8442  const RecordData &Record, unsigned &Idx) {
8443  ASTContext &Context = getContext();
8445  switch (Kind) {
8447  return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8448 
8452  return DeclarationName(ReadSelector(F, Record, Idx));
8453 
8455  return Context.DeclarationNames.getCXXConstructorName(
8456  Context.getCanonicalType(readType(F, Record, Idx)));
8457 
8459  return Context.DeclarationNames.getCXXDestructorName(
8460  Context.getCanonicalType(readType(F, Record, Idx)));
8461 
8464  ReadDeclAs<TemplateDecl>(F, Record, Idx));
8465 
8468  Context.getCanonicalType(readType(F, Record, Idx)));
8469 
8471  return Context.DeclarationNames.getCXXOperatorName(
8472  (OverloadedOperatorKind)Record[Idx++]);
8473 
8476  GetIdentifierInfo(F, Record, Idx));
8477 
8480  }
8481 
8482  llvm_unreachable("Invalid NameKind!");
8483 }
8484 
8486  DeclarationNameLoc &DNLoc,
8487  DeclarationName Name,
8488  const RecordData &Record, unsigned &Idx) {
8489  switch (Name.getNameKind()) {
8493  DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8494  break;
8495 
8498  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8500  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8501  break;
8502 
8505  = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8506  break;
8507 
8514  break;
8515  }
8516 }
8517 
8519  DeclarationNameInfo &NameInfo,
8520  const RecordData &Record, unsigned &Idx) {
8521  NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8522  NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8523  DeclarationNameLoc DNLoc;
8524  ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8525  NameInfo.setInfo(DNLoc);
8526 }
8527 
8529  const RecordData &Record, unsigned &Idx) {
8530  Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8531  unsigned NumTPLists = Record[Idx++];
8532  Info.NumTemplParamLists = NumTPLists;
8533  if (NumTPLists) {
8534  Info.TemplParamLists =
8535  new (getContext()) TemplateParameterList *[NumTPLists];
8536  for (unsigned i = 0; i != NumTPLists; ++i)
8537  Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8538  }
8539 }
8540 
8542 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8543  unsigned &Idx) {
8544  ASTContext &Context = getContext();
8546  switch (Kind) {
8548  return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8549 
8551  unsigned size = Record[Idx++];
8552  UnresolvedSet<8> Decls;
8553  while (size--)
8554  Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8555 
8556  return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8557  }
8558 
8560  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8561  bool hasTemplKeyword = Record[Idx++];
8562  TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8563  return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8564  }
8565 
8567  NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8568  if (Record[Idx++]) // isIdentifier
8569  return Context.getDependentTemplateName(NNS,
8570  GetIdentifierInfo(F, Record,
8571  Idx));
8572  return Context.getDependentTemplateName(NNS,
8573  (OverloadedOperatorKind)Record[Idx++]);
8574  }
8575 
8578  = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8579  if (!param) return TemplateName();
8580  TemplateName replacement = ReadTemplateName(F, Record, Idx);
8581  return Context.getSubstTemplateTemplateParm(param, replacement);
8582  }
8583 
8586  = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8587  if (!Param)
8588  return TemplateName();
8589 
8590  TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8591  if (ArgPack.getKind() != TemplateArgument::Pack)
8592  return TemplateName();
8593 
8594  return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8595  }
8596  }
8597 
8598  llvm_unreachable("Unhandled template name kind!");
8599 }
8600 
8602  const RecordData &Record,
8603  unsigned &Idx,
8604  bool Canonicalize) {
8605  ASTContext &Context = getContext();
8606  if (Canonicalize) {
8607  // The caller wants a canonical template argument. Sometimes the AST only
8608  // wants template arguments in canonical form (particularly as the template
8609  // argument lists of template specializations) so ensure we preserve that
8610  // canonical form across serialization.
8611  TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8612  return Context.getCanonicalTemplateArgument(Arg);
8613  }
8614 
8616  switch (Kind) {
8618  return TemplateArgument();
8620  return TemplateArgument(readType(F, Record, Idx));
8622  ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8623  return TemplateArgument(D, readType(F, Record, Idx));
8624  }
8626  return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8628  llvm::APSInt Value = ReadAPSInt(Record, Idx);
8629  QualType T = readType(F, Record, Idx);
8630  return TemplateArgument(Context, Value, T);
8631  }
8633  return TemplateArgument(ReadTemplateName(F, Record, Idx));
8635  TemplateName Name = ReadTemplateName(F, Record, Idx);
8636  Optional<unsigned> NumTemplateExpansions;
8637  if (unsigned NumExpansions = Record[Idx++])
8638  NumTemplateExpansions = NumExpansions - 1;
8639  return TemplateArgument(Name, NumTemplateExpansions);
8640  }
8642  return TemplateArgument(ReadExpr(F));
8643  case TemplateArgument::Pack: {
8644  unsigned NumArgs = Record[Idx++];
8645  TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8646  for (unsigned I = 0; I != NumArgs; ++I)
8647  Args[I] = ReadTemplateArgument(F, Record, Idx);
8648  return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8649  }
8650  }
8651 
8652  llvm_unreachable("Unhandled template argument kind!");
8653 }
8654 
8657  const RecordData &Record, unsigned &Idx) {
8658  SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8659  SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8660  SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8661 
8662  unsigned NumParams = Record[Idx++];
8664  Params.reserve(NumParams);
8665  while (NumParams--)
8666  Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8667 
8668  // TODO: Concepts
8670  getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8671  return TemplateParams;
8672 }
8673 
8674 void
8677  ModuleFile &F, const RecordData &Record,
8678  unsigned &Idx, bool Canonicalize) {
8679  unsigned NumTemplateArgs = Record[Idx++];
8680  TemplArgs.reserve(NumTemplateArgs);
8681  while (NumTemplateArgs--)
8682  TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8683 }
8684 
8685 /// \brief Read a UnresolvedSet structure.
8687  const RecordData &Record, unsigned &Idx) {
8688  unsigned NumDecls = Record[Idx++];
8689  Set.reserve(getContext(), NumDecls);
8690  while (NumDecls--) {
8691  DeclID ID = ReadDeclID(F, Record, Idx);
8692  AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8693  Set.addLazyDecl(getContext(), ID, AS);
8694  }
8695 }
8696 
8699  const RecordData &Record, unsigned &Idx) {
8700  bool isVirtual = static_cast<bool>(Record[Idx++]);
8701  bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8702  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8703  bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8704  TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8705  SourceRange Range = ReadSourceRange(F, Record, Idx);
8706  SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8707  CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8708  EllipsisLoc);
8709  Result.setInheritConstructors(inheritConstructors);
8710  return Result;
8711 }
8712 
8714 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8715  unsigned &Idx) {
8716  ASTContext &Context = getContext();
8717  unsigned NumInitializers = Record[Idx++];
8718  assert(NumInitializers && "wrote ctor initializers but have no inits");
8719  auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8720  for (unsigned i = 0; i != NumInitializers; ++i) {
8721  TypeSourceInfo *TInfo = nullptr;
8722  bool IsBaseVirtual = false;
8723  FieldDecl *Member = nullptr;
8724  IndirectFieldDecl *IndirectMember = nullptr;
8725 
8726  CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8727  switch (Type) {
8728  case CTOR_INITIALIZER_BASE:
8729  TInfo = GetTypeSourceInfo(F, Record, Idx);
8730  IsBaseVirtual = Record[Idx++];
8731  break;
8732 
8734  TInfo = GetTypeSourceInfo(F, Record, Idx);
8735  break;
8736 
8738  Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8739  break;
8740 
8742  IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8743  break;
8744  }
8745 
8746  SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8747  Expr *Init = ReadExpr(F);
8748  SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8749  SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8750 
8751  CXXCtorInitializer *BOMInit;
8752  if (Type == CTOR_INITIALIZER_BASE)
8753  BOMInit = new (Context)
8754  CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8755  RParenLoc, MemberOrEllipsisLoc);
8756  else if (Type == CTOR_INITIALIZER_DELEGATING)
8757  BOMInit = new (Context)
8758  CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8759  else if (Member)
8760  BOMInit = new (Context)
8761  CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8762  Init, RParenLoc);
8763  else
8764  BOMInit = new (Context)
8765  CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8766  LParenLoc, Init, RParenLoc);
8767 
8768  if (/*IsWritten*/Record[Idx++]) {
8769  unsigned SourceOrder = Record[Idx++];
8770  BOMInit->setSourceOrder(SourceOrder);
8771  }
8772 
8773  CtorInitializers[i] = BOMInit;
8774  }
8775 
8776  return CtorInitializers;
8777 }
8778 
8781  const RecordData &Record, unsigned &Idx) {
8782  ASTContext &Context = getContext();
8783  unsigned N = Record[Idx++];
8784  NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8785  for (unsigned I = 0; I != N; ++I) {
8787  = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8788  switch (Kind) {
8790  IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8791  NNS = NestedNameSpecifier::Create(Context, Prev, II);
8792  break;
8793  }
8794 
8796  NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8797  NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8798  break;
8799  }
8800 
8802  NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8803  NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8804  break;
8805  }
8806 
8809  const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8810  if (!T)
8811  return nullptr;
8812 
8813  bool Template = Record[Idx++];
8814  NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8815  break;
8816  }
8817 
8819  NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8820  // No associated value, and there can't be a prefix.
8821  break;
8822 
8824  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8825  NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8826  break;
8827  }
8828  }
8829  Prev = NNS;
8830  }
8831  return NNS;
8832 }
8833 
8836  unsigned &Idx) {
8837  ASTContext &Context = getContext();
8838  unsigned N = Record[Idx++];
8840  for (unsigned I = 0; I != N; ++I) {
8842  = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8843  switch (Kind) {
8845  IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8846  SourceRange Range = ReadSourceRange(F, Record, Idx);
8847  Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8848  break;
8849  }
8850 
8852  NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8853  SourceRange Range = ReadSourceRange(F, Record, Idx);
8854  Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8855  break;
8856  }
8857 
8859  NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8860  SourceRange Range = ReadSourceRange(F, Record, Idx);
8861  Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8862  break;
8863  }
8864 
8867  bool Template = Record[Idx++];
8868  TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
8869  if (!T)
8870  return NestedNameSpecifierLoc();
8871  SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8872 
8873  // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8874  Builder.Extend(Context,
8875  Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8876  T->getTypeLoc(), ColonColonLoc);
8877  break;
8878  }
8879 
8881  SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8882  Builder.MakeGlobal(Context, ColonColonLoc);
8883  break;
8884  }
8885 
8887  CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8888  SourceRange Range = ReadSourceRange(F, Record, Idx);
8889  Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8890  break;
8891  }
8892  }
8893  }
8894 
8895  return Builder.getWithLocInContext(Context);
8896 }
8897 
8899 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8900  unsigned &Idx) {
8901  SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8902  SourceLocation end = ReadSourceLocation(F, Record, Idx);
8903  return SourceRange(beg, end);
8904 }
8905 
8906 /// \brief Read an integral value
8907 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8908  unsigned BitWidth = Record[Idx++];
8909  unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8910  llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8911  Idx += NumWords;
8912  return Result;
8913 }
8914 
8915 /// \brief Read a signed integral value
8916 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8917  bool isUnsigned = Record[Idx++];
8918  return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8919 }
8920 
8921 /// \brief Read a floating-point value
8922 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8923  const llvm::fltSemantics &Sem,
8924  unsigned &Idx) {
8925  return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8926 }
8927 
8928 // \brief Read a string
8929 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8930  unsigned Len = Record[Idx++];
8931  std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8932  Idx += Len;
8933  return Result;
8934 }
8935 
8936 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
8937  unsigned &Idx) {
8938  std::string Filename = ReadString(Record, Idx);
8939  ResolveImportedPath(F, Filename);
8940  return Filename;
8941 }
8942 
8944  unsigned &Idx) {
8945  unsigned Major = Record[Idx++];
8946  unsigned Minor = Record[Idx++];
8947  unsigned Subminor = Record[Idx++];
8948  if (Minor == 0)
8949  return VersionTuple(Major);
8950  if (Subminor == 0)
8951  return VersionTuple(Major, Minor - 1);
8952  return VersionTuple(Major, Minor - 1, Subminor - 1);
8953 }
8954 
8956  const RecordData &Record,
8957  unsigned &Idx) {
8958  CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8959  return CXXTemporary::Create(getContext(), Decl);
8960 }
8961 
8962 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
8963  return Diag(CurrentImportLoc, DiagID);
8964 }
8965 
8966 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
8967  return Diags.Report(Loc, DiagID);
8968 }
8969 
8970 /// \brief Retrieve the identifier table associated with the
8971 /// preprocessor.
8973  return PP.getIdentifierTable();
8974 }
8975 
8976 /// \brief Record that the given ID maps to the given switch-case
8977 /// statement.
8979  assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8980  "Already have a SwitchCase with this ID");
8981  (*CurrSwitchCaseStmts)[ID] = SC;
8982 }
8983 
8984 /// \brief Retrieve the switch-case statement with the given ID.
8986  assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8987  return (*CurrSwitchCaseStmts)[ID];
8988 }
8989 
8991  CurrSwitchCaseStmts->clear();
8992 }
8993 
8995  ASTContext &Context = getContext();
8996  std::vector<RawComment *> Comments;
8997  for (SmallVectorImpl<std::pair<BitstreamCursor,
8998  serialization::ModuleFile *>>::iterator
8999  I = CommentsCursors.begin(),
9000  E = CommentsCursors.end();
9001  I != E; ++I) {
9002  Comments.clear();
9003  BitstreamCursor &Cursor = I->first;
9004  serialization::ModuleFile &F = *I->second;
9005  SavedStreamPosition SavedPosition(Cursor);
9006 
9007  RecordData Record;
9008  while (true) {
9009  llvm::BitstreamEntry Entry =
9010  Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
9011 
9012  switch (Entry.Kind) {
9013  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9015  Error("malformed block record in AST file");
9016  return;
9017  case llvm::BitstreamEntry::EndBlock:
9018  goto NextCursor;
9019  case llvm::BitstreamEntry::Record:
9020  // The interesting case.
9021  break;
9022  }
9023 
9024  // Read a record.
9025  Record.clear();
9026  switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
9027  case COMMENTS_RAW_COMMENT: {
9028  unsigned Idx = 0;
9029  SourceRange SR = ReadSourceRange(F, Record, Idx);
9031  (RawComment::CommentKind) Record[Idx++];
9032  bool IsTrailingComment = Record[Idx++];
9033  bool IsAlmostTrailingComment = Record[Idx++];
9034  Comments.push_back(new (Context) RawComment(
9035  SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
9037  break;
9038  }
9039  }
9040  }
9041  NextCursor:
9042  // De-serialized SourceLocations get negative FileIDs for other modules,
9043  // potentially invalidating the original order. Sort it again.
9044  std::sort(Comments.begin(), Comments.end(),
9045  BeforeThanCompare<RawComment>(SourceMgr));
9046  Context.Comments.addDeserializedComments(Comments);
9047  }
9048 }
9049 
9051  bool IncludeSystem, bool Complain,
9052  llvm::function_ref<void(const serialization::InputFile &IF,
9053  bool isSystem)> Visitor) {
9054  unsigned NumUserInputs = MF.NumUserInputFiles;
9055  unsigned NumInputs = MF.InputFilesLoaded.size();
9056  assert(NumUserInputs <= NumInputs);
9057  unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9058  for (unsigned I = 0; I < N; ++I) {
9059  bool IsSystem = I >= NumUserInputs;
9060  InputFile IF = getInputFile(MF, I+1, Complain);
9061  Visitor(IF, IsSystem);
9062  }
9063 }
9064 
9067  llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9068  unsigned NumInputs = MF.InputFilesLoaded.size();
9069  for (unsigned I = 0; I < NumInputs; ++I) {
9070  InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9071  if (IFI.TopLevelModuleMap)
9072  // FIXME: This unnecessarily re-reads the InputFileInfo.
9073  if (auto *FE = getInputFile(MF, I + 1).getFile())
9074  Visitor(FE);
9075  }
9076 }
9077 
9079  // If we know the owning module, use it.
9080  if (Module *M = D->getImportedOwningModule())
9081  return M->getFullModuleName();
9082 
9083  // Otherwise, use the name of the top-level module the decl is within.
9084  if (ModuleFile *M = getOwningModuleFile(D))
9085  return M->ModuleName;
9086 
9087  // Not from a module.
9088  return {};
9089 }
9090 
9091 void ASTReader::finishPendingActions() {
9092  while (!PendingIdentifierInfos.empty() ||
9093  !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9094  !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9095  !PendingUpdateRecords.empty()) {
9096  // If any identifiers with corresponding top-level declarations have
9097  // been loaded, load those declarations now.
9098  using TopLevelDeclsMap =
9099  llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9100  TopLevelDeclsMap TopLevelDecls;
9101 
9102  while (!PendingIdentifierInfos.empty()) {
9103  IdentifierInfo *II = PendingIdentifierInfos.back().first;
9104  SmallVector<uint32_t, 4> DeclIDs =
9105  std::move(PendingIdentifierInfos.back().second);
9106  PendingIdentifierInfos.pop_back();
9107 
9108  SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9109  }
9110 
9111  // For each decl chain that we wanted to complete while deserializing, mark
9112  // it as "still needs to be completed".
9113  for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9114  markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9115  }
9116  PendingIncompleteDeclChains.clear();
9117 
9118  // Load pending declaration chains.
9119  for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9120  loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
9121  PendingDeclChains.clear();
9122 
9123  // Make the most recent of the top-level declarations visible.
9124  for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9125  TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9126  IdentifierInfo *II = TLD->first;
9127  for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9128  pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9129  }
9130  }
9131 
9132  // Load any pending macro definitions.
9133  for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9134  IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9136  GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9137  // Initialize the macro history from chained-PCHs ahead of module imports.
9138  for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9139  ++IDIdx) {
9140  const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9141  if (!Info.M->isModule())
9142  resolvePendingMacro(II, Info);
9143  }
9144  // Handle module imports.
9145  for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9146  ++IDIdx) {
9147  const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9148  if (Info.M->isModule())
9149  resolvePendingMacro(II, Info);
9150  }
9151  }
9152  PendingMacroIDs.clear();
9153 
9154  // Wire up the DeclContexts for Decls that we delayed setting until
9155  // recursive loading is completed.
9156  while (!PendingDeclContextInfos.empty()) {
9157  PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9158  PendingDeclContextInfos.pop_front();
9159  DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9160  DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9161  Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9162  }
9163 
9164  // Perform any pending declaration updates.
9165  while (!PendingUpdateRecords.empty()) {
9166  auto Update = PendingUpdateRecords.pop_back_val();
9167  ReadingKindTracker ReadingKind(Read_Decl, *this);
9168  loadDeclUpdateRecords(Update);
9169  }
9170  }
9171 
9172  // At this point, all update records for loaded decls are in place, so any
9173  // fake class definitions should have become real.
9174  assert(PendingFakeDefinitionData.empty() &&
9175  "faked up a class definition but never saw the real one");
9176 
9177  // If we deserialized any C++ or Objective-C class definitions, any
9178  // Objective-C protocol definitions, or any redeclarable templates, make sure
9179  // that all redeclarations point to the definitions. Note that this can only
9180  // happen now, after the redeclaration chains have been fully wired.
9181  for (Decl *D : PendingDefinitions) {
9182  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9183  if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9184  // Make sure that the TagType points at the definition.
9185  const_cast<TagType*>(TagT)->decl = TD;
9186  }
9187 
9188  if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9189  for (auto *R = getMostRecentExistingDecl(RD); R;
9190  R = R->getPreviousDecl()) {
9191  assert((R == D) ==
9192  cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9193  "declaration thinks it's the definition but it isn't");
9194  cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9195  }
9196  }
9197 
9198  continue;
9199  }
9200 
9201  if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9202  // Make sure that the ObjCInterfaceType points at the definition.
9203  const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9204  ->Decl = ID;
9205 
9206  for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9207  cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9208 
9209  continue;
9210  }
9211 
9212  if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9213  for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9214  cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9215 
9216  continue;
9217  }
9218 
9219  auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9220  for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9221  cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9222  }
9223  PendingDefinitions.clear();
9224 
9225  // Load the bodies of any functions or methods we've encountered. We do
9226  // this now (delayed) so that we can be sure that the declaration chains
9227  // have been fully wired up (hasBody relies on this).
9228  // FIXME: We shouldn't require complete redeclaration chains here.
9229  for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9230  PBEnd = PendingBodies.end();
9231  PB != PBEnd; ++PB) {
9232  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9233  // FIXME: Check for =delete/=default?
9234  // FIXME: Complain about ODR violations here?
9235  const FunctionDecl *Defn = nullptr;
9236  if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9237  FD->setLazyBody(PB->second);
9238  } else {
9239  auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9240  mergeDefinitionVisibility(NonConstDefn, FD);
9241 
9242  if (!FD->isLateTemplateParsed() &&
9243  !NonConstDefn->isLateTemplateParsed() &&
9244  FD->getODRHash() != NonConstDefn->getODRHash()) {
9245  PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9246  }
9247  }
9248  continue;
9249  }
9250 
9251  ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9252  if (!getContext().getLangOpts().Modules || !MD->hasBody())
9253  MD->setLazyBody(PB->second);
9254  }
9255  PendingBodies.clear();
9256 
9257  // Do some cleanup.
9258  for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9259  getContext().deduplicateMergedDefinitonsFor(ND);
9260  PendingMergedDefinitionsToDeduplicate.clear();
9261 }
9262 
9263 void ASTReader::diagnoseOdrViolations() {
9264  if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9265  PendingFunctionOdrMergeFailures.empty())
9266  return;
9267 
9268  // Trigger the import of the full definition of each class that had any
9269  // odr-merging problems, so we can produce better diagnostics for them.
9270  // These updates may in turn find and diagnose some ODR failures, so take
9271  // ownership of the set first.
9272  auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9273  PendingOdrMergeFailures.clear();
9274  for (auto &Merge : OdrMergeFailures) {
9275  Merge.first->buildLookup();
9276  Merge.first->decls_begin();
9277  Merge.first->bases_begin();
9278  Merge.first->vbases_begin();
9279  for (auto &RecordPair : Merge.second) {
9280  auto *RD = RecordPair.first;
9281  RD->decls_begin();
9282  RD->bases_begin();
9283  RD->vbases_begin();
9284  }
9285  }
9286 
9287  // Trigger the import of functions.
9288  auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9289  PendingFunctionOdrMergeFailures.clear();
9290  for (auto &Merge : FunctionOdrMergeFailures) {
9291  Merge.first->buildLookup();
9292  Merge.first->decls_begin();
9293  Merge.first->getBody();
9294  for (auto &FD : Merge.second) {
9295  FD->buildLookup();
9296  FD->decls_begin();
9297  FD->getBody();
9298  }
9299  }
9300 
9301  // For each declaration from a merged context, check that the canonical
9302  // definition of that context also contains a declaration of the same
9303  // entity.
9304  //
9305  // Caution: this loop does things that might invalidate iterators into
9306  // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9307  while (!PendingOdrMergeChecks.empty()) {
9308  NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9309 
9310  // FIXME: Skip over implicit declarations for now. This matters for things
9311  // like implicitly-declared special member functions. This isn't entirely
9312  // correct; we can end up with multiple unmerged declarations of the same
9313  // implicit entity.
9314  if (D->isImplicit())
9315  continue;
9316 
9317  DeclContext *CanonDef = D->getDeclContext();
9318 
9319  bool Found = false;
9320  const Decl *DCanon = D->getCanonicalDecl();
9321 
9322  for (auto RI : D->redecls()) {
9323  if (RI->getLexicalDeclContext() == CanonDef) {
9324  Found = true;
9325  break;
9326  }
9327  }
9328  if (Found)
9329  continue;
9330 
9331  // Quick check failed, time to do the slow thing. Note, we can't just
9332  // look up the name of D in CanonDef here, because the member that is
9333  // in CanonDef might not be found by name lookup (it might have been
9334  // replaced by a more recent declaration in the lookup table), and we
9335  // can't necessarily find it in the redeclaration chain because it might
9336  // be merely mergeable, not redeclarable.
9338  for (auto *CanonMember : CanonDef->decls()) {
9339  if (CanonMember->getCanonicalDecl() == DCanon) {
9340  // This can happen if the declaration is merely mergeable and not
9341  // actually redeclarable (we looked for redeclarations earlier).
9342  //
9343  // FIXME: We should be able to detect this more efficiently, without
9344  // pulling in all of the members of CanonDef.
9345  Found = true;
9346  break;
9347  }
9348  if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9349  if (ND->getDeclName() == D->getDeclName())
9350  Candidates.push_back(ND);
9351  }
9352 
9353  if (!Found) {
9354  // The AST doesn't like TagDecls becoming invalid after they've been
9355  // completed. We only really need to mark FieldDecls as invalid here.
9356  if (!isa<TagDecl>(D))
9357  D->setInvalidDecl();
9358 
9359  // Ensure we don't accidentally recursively enter deserialization while
9360  // we're producing our diagnostic.
9361  Deserializing RecursionGuard(this);
9362 
9363  std::string CanonDefModule =
9364  getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9365  Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9366  << D << getOwningModuleNameForDiagnostic(D)
9367  << CanonDef << CanonDefModule.empty() << CanonDefModule;
9368 
9369  if (Candidates.empty())
9370  Diag(cast<Decl>(CanonDef)->getLocation(),
9371  diag::note_module_odr_violation_no_possible_decls) << D;
9372  else {
9373  for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9374  Diag(Candidates[I]->getLocation(),
9375  diag::note_module_odr_violation_possible_decl)
9376  << Candidates[I];
9377  }
9378 
9379  DiagnosedOdrMergeFailures.insert(CanonDef);
9380  }
9381  }
9382 
9383  if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty())
9384  return;
9385 
9386  // Ensure we don't accidentally recursively enter deserialization while
9387  // we're producing our diagnostics.
9388  Deserializing RecursionGuard(this);
9389 
9390  // Common code for hashing helpers.
9391  ODRHash Hash;
9392  auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9393  Hash.clear();
9394  Hash.AddQualType(Ty);
9395  return Hash.CalculateHash();
9396  };
9397 
9398  auto ComputeODRHash = [&Hash](const Stmt *S) {
9399  assert(S);
9400  Hash.clear();
9401  Hash.AddStmt(S);
9402  return Hash.CalculateHash();
9403  };
9404 
9405  auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9406  assert(D);
9407  Hash.clear();
9408  Hash.AddSubDecl(D);
9409  return Hash.CalculateHash();
9410  };
9411 
9412  // Issue any pending ODR-failure diagnostics.
9413  for (auto &Merge : OdrMergeFailures) {
9414  // If we've already pointed out a specific problem with this class, don't
9415  // bother issuing a general "something's different" diagnostic.
9416  if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9417  continue;
9418 
9419  bool Diagnosed = false;
9420  CXXRecordDecl *FirstRecord = Merge.first;
9421  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9422  for (auto &RecordPair : Merge.second) {
9423  CXXRecordDecl *SecondRecord = RecordPair.first;
9424  // Multiple different declarations got merged together; tell the user
9425  // where they came from.
9426  if (FirstRecord == SecondRecord)
9427  continue;
9428 
9429  std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9430 
9431  auto *FirstDD = FirstRecord->DefinitionData;
9432  auto *SecondDD = RecordPair.second;
9433 
9434  assert(FirstDD && SecondDD && "Definitions without DefinitionData");
9435 
9436  // Diagnostics from DefinitionData are emitted here.
9437  if (FirstDD != SecondDD) {
9438  enum ODRDefinitionDataDifference {
9439  NumBases,
9440  NumVBases,
9441  BaseType,
9442  BaseVirtual,
9443  BaseAccess,
9444  };
9445  auto ODRDiagError = [FirstRecord, &FirstModule,
9446  this](SourceLocation Loc, SourceRange Range,
9447  ODRDefinitionDataDifference DiffType) {
9448  return Diag(Loc, diag::err_module_odr_violation_definition_data)
9449  << FirstRecord << FirstModule.empty() << FirstModule << Range
9450  << DiffType;
9451  };
9452  auto ODRDiagNote = [&SecondModule,
9453  this](SourceLocation Loc, SourceRange Range,
9454  ODRDefinitionDataDifference DiffType) {
9455  return Diag(Loc, diag::note_module_odr_violation_definition_data)
9456  << SecondModule << Range << DiffType;
9457  };
9458 
9459  unsigned FirstNumBases = FirstDD->NumBases;
9460  unsigned FirstNumVBases = FirstDD->NumVBases;
9461  unsigned SecondNumBases = SecondDD->NumBases;
9462  unsigned SecondNumVBases = SecondDD->NumVBases;
9463 
9464  auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
9465  unsigned NumBases = DD->NumBases;
9466  if (NumBases == 0) return SourceRange();
9467  auto bases = DD->bases();
9468  return SourceRange(bases[0].getLocStart(),
9469  bases[NumBases - 1].getLocEnd());
9470  };
9471 
9472  if (FirstNumBases != SecondNumBases) {
9473  ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9474  NumBases)
9475  << FirstNumBases;
9476  ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9477  NumBases)
9478  << SecondNumBases;
9479  Diagnosed = true;
9480  break;
9481  }
9482 
9483  if (FirstNumVBases != SecondNumVBases) {
9484  ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9485  NumVBases)
9486  << FirstNumVBases;
9487  ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9488  NumVBases)
9489  << SecondNumVBases;
9490  Diagnosed = true;
9491  break;
9492  }
9493 
9494  auto FirstBases = FirstDD->bases();
9495  auto SecondBases = SecondDD->bases();
9496  unsigned i = 0;
9497  for (i = 0; i < FirstNumBases; ++i) {
9498  auto FirstBase = FirstBases[i];
9499  auto SecondBase = SecondBases[i];
9500  if (ComputeQualTypeODRHash(FirstBase.getType()) !=
9501  ComputeQualTypeODRHash(SecondBase.getType())) {
9502  ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9503  BaseType)
9504  << (i + 1) << FirstBase.getType();
9505  ODRDiagNote(SecondRecord->getLocation(),
9506  SecondBase.getSourceRange(), BaseType)
9507  << (i + 1) << SecondBase.getType();
9508  break;
9509  }
9510 
9511  if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
9512  ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9513  BaseVirtual)
9514  << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
9515  ODRDiagNote(SecondRecord->getLocation(),
9516  SecondBase.getSourceRange(), BaseVirtual)
9517  << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
9518  break;
9519  }
9520 
9521  if (FirstBase.getAccessSpecifierAsWritten() !=
9522  SecondBase.getAccessSpecifierAsWritten()) {
9523  ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9524  BaseAccess)
9525  << (i + 1) << FirstBase.getType()
9526  << (int)FirstBase.getAccessSpecifierAsWritten();
9527  ODRDiagNote(SecondRecord->getLocation(),
9528  SecondBase.getSourceRange(), BaseAccess)
9529  << (i + 1) << SecondBase.getType()
9530  << (int)SecondBase.getAccessSpecifierAsWritten();
9531  break;
9532  }
9533  }
9534 
9535  if (i != FirstNumBases) {
9536  Diagnosed = true;
9537  break;
9538  }
9539  }
9540 
9541  using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9542 
9543  const ClassTemplateDecl *FirstTemplate =
9544  FirstRecord->getDescribedClassTemplate();
9545  const ClassTemplateDecl *SecondTemplate =
9546  SecondRecord->getDescribedClassTemplate();
9547 
9548  assert(!FirstTemplate == !SecondTemplate &&
9549  "Both pointers should be null or non-null");
9550 
9551  enum ODRTemplateDifference {
9552  ParamEmptyName,
9553  ParamName,
9554  ParamSingleDefaultArgument,
9555  ParamDifferentDefaultArgument,
9556  };
9557 
9558  if (FirstTemplate && SecondTemplate) {
9559  DeclHashes FirstTemplateHashes;
9560  DeclHashes SecondTemplateHashes;
9561 
9562  auto PopulateTemplateParameterHashs =
9563  [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9564  const ClassTemplateDecl *TD) {
9565  for (auto *D : TD->getTemplateParameters()->asArray()) {
9566  Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9567  }
9568  };
9569 
9570  PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
9571  PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
9572 
9573  assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
9574  "Number of template parameters should be equal.");
9575 
9576  auto FirstIt = FirstTemplateHashes.begin();
9577  auto FirstEnd = FirstTemplateHashes.end();
9578  auto SecondIt = SecondTemplateHashes.begin();
9579  for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
9580  if (FirstIt->second == SecondIt->second)
9581  continue;
9582 
9583  auto ODRDiagError = [FirstRecord, &FirstModule,
9584  this](SourceLocation Loc, SourceRange Range,
9585  ODRTemplateDifference DiffType) {
9586  return Diag(Loc, diag::err_module_odr_violation_template_parameter)
9587  << FirstRecord << FirstModule.empty() << FirstModule << Range
9588  << DiffType;
9589  };
9590  auto ODRDiagNote = [&SecondModule,
9591  this](SourceLocation Loc, SourceRange Range,
9592  ODRTemplateDifference DiffType) {
9593  return Diag(Loc, diag::note_module_odr_violation_template_parameter)
9594  << SecondModule << Range << DiffType;
9595  };
9596 
9597  const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
9598  const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
9599 
9600  assert(FirstDecl->getKind() == SecondDecl->getKind() &&
9601  "Parameter Decl's should be the same kind.");
9602 
9603  DeclarationName FirstName = FirstDecl->getDeclName();
9604  DeclarationName SecondName = SecondDecl->getDeclName();
9605 
9606  if (FirstName != SecondName) {
9607  const bool FirstNameEmpty =
9608  FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
9609  const bool SecondNameEmpty =
9610  SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
9611  assert((!FirstNameEmpty || !SecondNameEmpty) &&
9612  "Both template parameters cannot be unnamed.");
9613  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9614  FirstNameEmpty ? ParamEmptyName : ParamName)
9615  << FirstName;
9616  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9617  SecondNameEmpty ? ParamEmptyName : ParamName)
9618  << SecondName;
9619  break;
9620  }
9621 
9622  switch (FirstDecl->getKind()) {
9623  default:
9624  llvm_unreachable("Invalid template parameter type.");
9625  case Decl::TemplateTypeParm: {
9626  const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
9627  const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
9628  const bool HasFirstDefaultArgument =
9629  FirstParam->hasDefaultArgument() &&
9630  !FirstParam->defaultArgumentWasInherited();
9631  const bool HasSecondDefaultArgument =
9632  SecondParam->hasDefaultArgument() &&
9633  !SecondParam->defaultArgumentWasInherited();
9634 
9635  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9636  ODRDiagError(FirstDecl->getLocation(),
9637  FirstDecl->getSourceRange(),
9638  ParamSingleDefaultArgument)
9639  << HasFirstDefaultArgument;
9640  ODRDiagNote(SecondDecl->getLocation(),
9641  SecondDecl->getSourceRange(),
9642  ParamSingleDefaultArgument)
9643  << HasSecondDefaultArgument;
9644  break;
9645  }
9646 
9647  assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9648  "Expecting default arguments.");
9649 
9650  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9651  ParamDifferentDefaultArgument);
9652  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9653  ParamDifferentDefaultArgument);
9654 
9655  break;
9656  }
9657  case Decl::NonTypeTemplateParm: {
9658  const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
9659  const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
9660  const bool HasFirstDefaultArgument =
9661  FirstParam->hasDefaultArgument() &&
9662  !FirstParam->defaultArgumentWasInherited();
9663  const bool HasSecondDefaultArgument =
9664  SecondParam->hasDefaultArgument() &&
9665  !SecondParam->defaultArgumentWasInherited();
9666 
9667  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9668  ODRDiagError(FirstDecl->getLocation(),
9669  FirstDecl->getSourceRange(),
9670  ParamSingleDefaultArgument)
9671  << HasFirstDefaultArgument;
9672  ODRDiagNote(SecondDecl->getLocation(),
9673  SecondDecl->getSourceRange(),
9674  ParamSingleDefaultArgument)
9675  << HasSecondDefaultArgument;
9676  break;
9677  }
9678 
9679  assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9680  "Expecting default arguments.");
9681 
9682  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9683  ParamDifferentDefaultArgument);
9684  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9685  ParamDifferentDefaultArgument);
9686 
9687  break;
9688  }
9689  case Decl::TemplateTemplateParm: {
9690  const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
9691  const auto *SecondParam =
9692  cast<TemplateTemplateParmDecl>(SecondDecl);
9693  const bool HasFirstDefaultArgument =
9694  FirstParam->hasDefaultArgument() &&
9695  !FirstParam->defaultArgumentWasInherited();
9696  const bool HasSecondDefaultArgument =
9697  SecondParam->hasDefaultArgument() &&
9698  !SecondParam->defaultArgumentWasInherited();
9699 
9700  if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9701  ODRDiagError(FirstDecl->getLocation(),
9702  FirstDecl->getSourceRange(),
9703  ParamSingleDefaultArgument)
9704  << HasFirstDefaultArgument;
9705  ODRDiagNote(SecondDecl->getLocation(),
9706  SecondDecl->getSourceRange(),
9707  ParamSingleDefaultArgument)
9708  << HasSecondDefaultArgument;
9709  break;
9710  }
9711 
9712  assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
9713  "Expecting default arguments.");
9714 
9715  ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9716  ParamDifferentDefaultArgument);
9717  ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9718  ParamDifferentDefaultArgument);
9719 
9720  break;
9721  }
9722  }
9723 
9724  break;
9725  }
9726 
9727  if (FirstIt != FirstEnd) {
9728  Diagnosed = true;
9729  break;
9730  }
9731  }
9732 
9733  DeclHashes FirstHashes;
9734  DeclHashes SecondHashes;
9735 
9736  auto PopulateHashes = [&ComputeSubDeclODRHash, FirstRecord](
9737  DeclHashes &Hashes, CXXRecordDecl *Record) {
9738  for (auto *D : Record->decls()) {
9739  // Due to decl merging, the first CXXRecordDecl is the parent of
9740  // Decls in both records.
9741  if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
9742  continue;
9743  Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9744  }
9745  };
9746  PopulateHashes(FirstHashes, FirstRecord);
9747  PopulateHashes(SecondHashes, SecondRecord);
9748 
9749  // Used with err_module_odr_violation_mismatch_decl and
9750  // note_module_odr_violation_mismatch_decl
9751  // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
9752  enum {
9753  EndOfClass,
9754  PublicSpecifer,
9755  PrivateSpecifer,
9756  ProtectedSpecifer,
9757  StaticAssert,
9758  Field,
9759  CXXMethod,
9760  TypeAlias,
9761  TypeDef,
9762  Var,
9763  Friend,
9764  Other
9765  } FirstDiffType = Other,
9766  SecondDiffType = Other;
9767 
9768  auto DifferenceSelector = [](Decl *D) {
9769  assert(D && "valid Decl required");
9770  switch (D->getKind()) {
9771  default:
9772  return Other;
9773  case Decl::AccessSpec:
9774  switch (D->getAccess()) {
9775  case AS_public:
9776  return PublicSpecifer;
9777  case AS_private:
9778  return PrivateSpecifer;
9779  case AS_protected:
9780  return ProtectedSpecifer;
9781  case AS_none:
9782  break;
9783  }
9784  llvm_unreachable("Invalid access specifier");
9785  case Decl::StaticAssert:
9786  return StaticAssert;
9787  case Decl::Field:
9788  return Field;
9789  case Decl::CXXMethod:
9790  case Decl::CXXConstructor:
9791  case Decl::CXXDestructor:
9792  return CXXMethod;
9793  case Decl::TypeAlias:
9794  return TypeAlias;
9795  case Decl::Typedef:
9796  return TypeDef;
9797  case Decl::Var:
9798  return Var;
9799  case Decl::Friend:
9800  return Friend;
9801  }
9802  };
9803 
9804  Decl *FirstDecl = nullptr;
9805  Decl *SecondDecl = nullptr;
9806  auto FirstIt = FirstHashes.begin();
9807  auto SecondIt = SecondHashes.begin();
9808 
9809  // If there is a diagnoseable difference, FirstDiffType and
9810  // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
9811  // filled in if not EndOfClass.
9812  while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
9813  if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
9814  FirstIt->second == SecondIt->second) {
9815  ++FirstIt;
9816  ++SecondIt;
9817  continue;
9818  }
9819 
9820  FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
9821  SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
9822 
9823  FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
9824  SecondDiffType =
9825  SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
9826 
9827  break;
9828  }
9829 
9830  if (FirstDiffType == Other || SecondDiffType == Other) {
9831  // Reaching this point means an unexpected Decl was encountered
9832  // or no difference was detected. This causes a generic error
9833  // message to be emitted.
9834  Diag(FirstRecord->getLocation(),
9835  diag::err_module_odr_violation_different_definitions)
9836  << FirstRecord << FirstModule.empty() << FirstModule;
9837 
9838  if (FirstDecl) {
9839  Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
9840  << FirstRecord << FirstDecl->getSourceRange();
9841  }
9842 
9843  Diag(SecondRecord->getLocation(),
9844  diag::note_module_odr_violation_different_definitions)
9845  << SecondModule;
9846 
9847  if (SecondDecl) {
9848  Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
9849  << SecondDecl->getSourceRange();
9850  }
9851 
9852  Diagnosed = true;
9853  break;
9854  }
9855 
9856  if (FirstDiffType != SecondDiffType) {
9857  SourceLocation FirstLoc;
9858  SourceRange FirstRange;
9859  if (FirstDiffType == EndOfClass) {
9860  FirstLoc = FirstRecord->getBraceRange().getEnd();
9861  } else {
9862  FirstLoc = FirstIt->first->getLocation();
9863  FirstRange = FirstIt->first->getSourceRange();
9864  }
9865  Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
9866  << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
9867  << FirstDiffType;
9868 
9869  SourceLocation SecondLoc;
9870  SourceRange SecondRange;
9871  if (SecondDiffType == EndOfClass) {
9872  SecondLoc = SecondRecord->getBraceRange().getEnd();
9873  } else {
9874  SecondLoc = SecondDecl->getLocation();
9875  SecondRange = SecondDecl->getSourceRange();
9876  }
9877  Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
9878  << SecondModule << SecondRange << SecondDiffType;
9879  Diagnosed = true;
9880  break;
9881  }
9882 
9883  assert(FirstDiffType == SecondDiffType);
9884 
9885  // Used with err_module_odr_violation_mismatch_decl_diff and
9886  // note_module_odr_violation_mismatch_decl_diff
9887  enum ODRDeclDifference{
9888  StaticAssertCondition,
9889  StaticAssertMessage,
9890  StaticAssertOnlyMessage,
9891  FieldName,
9892  FieldTypeName,
9893  FieldSingleBitField,
9894  FieldDifferentWidthBitField,
9895  FieldSingleMutable,
9896  FieldSingleInitializer,
9897  FieldDifferentInitializers,
9898  MethodName,
9899  MethodDeleted,
9900  MethodVirtual,
9901  MethodStatic,
9902  MethodVolatile,
9903  MethodConst,
9904  MethodInline,
9905  MethodNumberParameters,
9906  MethodParameterType,
9907  MethodParameterName,
9908  MethodParameterSingleDefaultArgument,
9909  MethodParameterDifferentDefaultArgument,
9910  TypedefName,
9911  TypedefType,
9912  VarName,
9913  VarType,
9914  VarSingleInitializer,
9915  VarDifferentInitializer,
9916  VarConstexpr,
9917  FriendTypeFunction,
9918  FriendType,
9919  FriendFunction,
9920  };
9921 
9922  // These lambdas have the common portions of the ODR diagnostics. This
9923  // has the same return as Diag(), so addition parameters can be passed
9924  // in with operator<<
9925  auto ODRDiagError = [FirstRecord, &FirstModule, this](
9926  SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
9927  return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
9928  << FirstRecord << FirstModule.empty() << FirstModule << Range
9929  << DiffType;
9930  };
9931  auto ODRDiagNote = [&SecondModule, this](
9932  SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
9933  return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
9934  << SecondModule << Range << DiffType;
9935  };
9936 
9937  switch (FirstDiffType) {
9938  case Other:
9939  case EndOfClass:
9940  case PublicSpecifer:
9941  case PrivateSpecifer:
9942  case ProtectedSpecifer:
9943  llvm_unreachable("Invalid diff type");
9944 
9945  case StaticAssert: {
9946  StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
9947  StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
9948 
9949  Expr *FirstExpr = FirstSA->getAssertExpr();
9950  Expr *SecondExpr = SecondSA->getAssertExpr();
9951  unsigned FirstODRHash = ComputeODRHash(FirstExpr);
9952  unsigned SecondODRHash = ComputeODRHash(SecondExpr);
9953  if (FirstODRHash != SecondODRHash) {
9954  ODRDiagError(FirstExpr->getLocStart(), FirstExpr->getSourceRange(),
9955  StaticAssertCondition);
9956  ODRDiagNote(SecondExpr->getLocStart(),
9957  SecondExpr->getSourceRange(), StaticAssertCondition);
9958  Diagnosed = true;
9959  break;
9960  }
9961 
9962  StringLiteral *FirstStr = FirstSA->getMessage();
9963  StringLiteral *SecondStr = SecondSA->getMessage();
9964  assert((FirstStr || SecondStr) && "Both messages cannot be empty");
9965  if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
9966  SourceLocation FirstLoc, SecondLoc;
9967  SourceRange FirstRange, SecondRange;
9968  if (FirstStr) {
9969  FirstLoc = FirstStr->getLocStart();
9970  FirstRange = FirstStr->getSourceRange();
9971  } else {
9972  FirstLoc = FirstSA->getLocStart();
9973  FirstRange = FirstSA->getSourceRange();
9974  }
9975  if (SecondStr) {
9976  SecondLoc = SecondStr->getLocStart();
9977  SecondRange = SecondStr->getSourceRange();
9978  } else {
9979  SecondLoc = SecondSA->getLocStart();
9980  SecondRange = SecondSA->getSourceRange();
9981  }
9982  ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
9983  << (FirstStr == nullptr);
9984  ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
9985  << (SecondStr == nullptr);
9986  Diagnosed = true;
9987  break;
9988  }
9989 
9990  if (FirstStr && SecondStr &&
9991  FirstStr->getString() != SecondStr->getString()) {
9992  ODRDiagError(FirstStr->getLocStart(), FirstStr->getSourceRange(),
9993  StaticAssertMessage);
9994  ODRDiagNote(SecondStr->getLocStart(), SecondStr->getSourceRange(),
9995  StaticAssertMessage);
9996  Diagnosed = true;
9997  break;
9998  }
9999  break;
10000  }
10001  case Field: {
10002  FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
10003  FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
10004  IdentifierInfo *FirstII = FirstField->getIdentifier();
10005  IdentifierInfo *SecondII = SecondField->getIdentifier();
10006  if (FirstII->getName() != SecondII->getName()) {
10007  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10008  FieldName)
10009  << FirstII;
10010  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10011  FieldName)
10012  << SecondII;
10013 
10014  Diagnosed = true;
10015  break;
10016  }
10017 
10018  assert(getContext().hasSameType(FirstField->getType(),
10019  SecondField->getType()));
10020 
10021  QualType FirstType = FirstField->getType();
10022  QualType SecondType = SecondField->getType();
10023  if (ComputeQualTypeODRHash(FirstType) !=
10024  ComputeQualTypeODRHash(SecondType)) {
10025  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10026  FieldTypeName)
10027  << FirstII << FirstType;
10028  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10029  FieldTypeName)
10030  << SecondII << SecondType;
10031 
10032  Diagnosed = true;
10033  break;
10034  }
10035 
10036  const bool IsFirstBitField = FirstField->isBitField();
10037  const bool IsSecondBitField = SecondField->isBitField();
10038  if (IsFirstBitField != IsSecondBitField) {
10039  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10040  FieldSingleBitField)
10041  << FirstII << IsFirstBitField;
10042  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10043  FieldSingleBitField)
10044  << SecondII << IsSecondBitField;
10045  Diagnosed = true;
10046  break;
10047  }
10048 
10049  if (IsFirstBitField && IsSecondBitField) {
10050  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10051  FieldDifferentWidthBitField)
10052  << FirstII << FirstField->getBitWidth()->getSourceRange();
10053  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10054  FieldDifferentWidthBitField)
10055  << SecondII << SecondField->getBitWidth()->getSourceRange();
10056  Diagnosed = true;
10057  break;
10058  }
10059 
10060  const bool IsFirstMutable = FirstField->isMutable();
10061  const bool IsSecondMutable = SecondField->isMutable();
10062  if (IsFirstMutable != IsSecondMutable) {
10063  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10064  FieldSingleMutable)
10065  << FirstII << IsFirstMutable;
10066  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10067  FieldSingleMutable)
10068  << SecondII << IsSecondMutable;
10069  Diagnosed = true;
10070  break;
10071  }
10072 
10073  const Expr *FirstInitializer = FirstField->getInClassInitializer();
10074  const Expr *SecondInitializer = SecondField->getInClassInitializer();
10075  if ((!FirstInitializer && SecondInitializer) ||
10076  (FirstInitializer && !SecondInitializer)) {
10077  ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10078  FieldSingleInitializer)
10079  << FirstII << (FirstInitializer != nullptr);
10080  ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10081  FieldSingleInitializer)
10082  << SecondII << (SecondInitializer != nullptr);
10083  Diagnosed = true;
10084  break;
10085  }
10086 
10087  if (FirstInitializer && SecondInitializer) {
10088  unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
10089  unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
10090  if (FirstInitHash != SecondInitHash) {
10091  ODRDiagError(FirstField->getLocation(),
10092  FirstField->getSourceRange(),
10093  FieldDifferentInitializers)
10094  << FirstII << FirstInitializer->getSourceRange();
10095  ODRDiagNote(SecondField->getLocation(),
10096  SecondField->getSourceRange(),
10097  FieldDifferentInitializers)
10098  << SecondII << SecondInitializer->getSourceRange();
10099  Diagnosed = true;
10100  break;
10101  }
10102  }
10103 
10104  break;
10105  }
10106  case CXXMethod: {
10107  enum {
10108  DiagMethod,
10109  DiagConstructor,
10110  DiagDestructor,
10111  } FirstMethodType,
10112  SecondMethodType;
10113  auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10114  if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10115  if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10116  return DiagMethod;
10117  };
10118  const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10119  const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10120  FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10121  SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10122  auto FirstName = FirstMethod->getDeclName();
10123  auto SecondName = SecondMethod->getDeclName();
10124  if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10125  ODRDiagError(FirstMethod->getLocation(),
10126  FirstMethod->getSourceRange(), MethodName)
10127  << FirstMethodType << FirstName;
10128  ODRDiagNote(SecondMethod->getLocation(),
10129  SecondMethod->getSourceRange(), MethodName)
10130  << SecondMethodType << SecondName;
10131 
10132  Diagnosed = true;
10133  break;
10134  }
10135 
10136  const bool FirstDeleted = FirstMethod->isDeleted();
10137  const bool SecondDeleted = SecondMethod->isDeleted();
10138  if (FirstDeleted != SecondDeleted) {
10139  ODRDiagError(FirstMethod->getLocation(),
10140  FirstMethod->getSourceRange(), MethodDeleted)
10141  << FirstMethodType << FirstName << FirstDeleted;
10142 
10143  ODRDiagNote(SecondMethod->getLocation(),
10144  SecondMethod->getSourceRange(), MethodDeleted)
10145  << SecondMethodType << SecondName << SecondDeleted;
10146  Diagnosed = true;
10147  break;
10148  }
10149 
10150  const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10151  const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10152  const bool FirstPure = FirstMethod->isPure();
10153  const bool SecondPure = SecondMethod->isPure();
10154  if ((FirstVirtual || SecondVirtual) &&
10155  (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10156  ODRDiagError(FirstMethod->getLocation(),
10157  FirstMethod->getSourceRange(), MethodVirtual)
10158  << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10159  ODRDiagNote(SecondMethod->getLocation(),
10160  SecondMethod->getSourceRange(), MethodVirtual)
10161  << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10162  Diagnosed = true;
10163  break;
10164  }
10165 
10166  // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10167  // FirstDecl is the canonical Decl of SecondDecl, so the storage
10168  // class needs to be checked instead.
10169  const auto FirstStorage = FirstMethod->getStorageClass();
10170  const auto SecondStorage = SecondMethod->getStorageClass();
10171  const bool FirstStatic = FirstStorage == SC_Static;
10172  const bool SecondStatic = SecondStorage == SC_Static;
10173  if (FirstStatic != SecondStatic) {
10174  ODRDiagError(FirstMethod->getLocation(),
10175  FirstMethod->getSourceRange(), MethodStatic)
10176  << FirstMethodType << FirstName << FirstStatic;
10177  ODRDiagNote(SecondMethod->getLocation(),
10178  SecondMethod->getSourceRange(), MethodStatic)
10179  << SecondMethodType << SecondName << SecondStatic;
10180  Diagnosed = true;
10181  break;
10182  }
10183 
10184  const bool FirstVolatile = FirstMethod->isVolatile();
10185  const bool SecondVolatile = SecondMethod->isVolatile();
10186  if (FirstVolatile != SecondVolatile) {
10187  ODRDiagError(FirstMethod->getLocation(),
10188  FirstMethod->getSourceRange(), MethodVolatile)
10189  << FirstMethodType << FirstName << FirstVolatile;
10190  ODRDiagNote(SecondMethod->getLocation(),
10191  SecondMethod->getSourceRange(), MethodVolatile)
10192  << SecondMethodType << SecondName << SecondVolatile;
10193  Diagnosed = true;
10194  break;
10195  }
10196 
10197  const bool FirstConst = FirstMethod->isConst();
10198  const bool SecondConst = SecondMethod->isConst();
10199  if (FirstConst != SecondConst) {
10200  ODRDiagError(FirstMethod->getLocation(),
10201  FirstMethod->getSourceRange(), MethodConst)
10202  << FirstMethodType << FirstName << FirstConst;
10203  ODRDiagNote(SecondMethod->getLocation(),
10204  SecondMethod->getSourceRange(), MethodConst)
10205  << SecondMethodType << SecondName << SecondConst;
10206  Diagnosed = true;
10207  break;
10208  }
10209 
10210  const bool FirstInline = FirstMethod->isInlineSpecified();
10211  const bool SecondInline = SecondMethod->isInlineSpecified();
10212  if (FirstInline != SecondInline) {
10213  ODRDiagError(FirstMethod->getLocation(),
10214  FirstMethod->getSourceRange(), MethodInline)
10215  << FirstMethodType << FirstName << FirstInline;
10216  ODRDiagNote(SecondMethod->getLocation(),
10217  SecondMethod->getSourceRange(), MethodInline)
10218  << SecondMethodType << SecondName << SecondInline;
10219  Diagnosed = true;
10220  break;
10221  }
10222 
10223  const unsigned FirstNumParameters = FirstMethod->param_size();
10224  const unsigned SecondNumParameters = SecondMethod->param_size();
10225  if (FirstNumParameters != SecondNumParameters) {
10226  ODRDiagError(FirstMethod->getLocation(),
10227  FirstMethod->getSourceRange(), MethodNumberParameters)
10228  << FirstMethodType << FirstName << FirstNumParameters;
10229  ODRDiagNote(SecondMethod->getLocation(),
10230  SecondMethod->getSourceRange(), MethodNumberParameters)
10231  << SecondMethodType << SecondName << SecondNumParameters;
10232  Diagnosed = true;
10233  break;
10234  }
10235 
10236  // Need this status boolean to know when break out of the switch.
10237  bool ParameterMismatch = false;
10238  for (unsigned I = 0; I < FirstNumParameters; ++I) {
10239  const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10240  const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10241 
10242  QualType FirstParamType = FirstParam->getType();
10243  QualType SecondParamType = SecondParam->getType();
10244  if (FirstParamType != SecondParamType &&
10245  ComputeQualTypeODRHash(FirstParamType) !=
10246  ComputeQualTypeODRHash(SecondParamType)) {
10247  if (const DecayedType *ParamDecayedType =
10248  FirstParamType->getAs<DecayedType>()) {
10249  ODRDiagError(FirstMethod->getLocation(),
10250  FirstMethod->getSourceRange(), MethodParameterType)
10251  << FirstMethodType << FirstName << (I + 1) << FirstParamType
10252  << true << ParamDecayedType->getOriginalType();
10253  } else {
10254  ODRDiagError(FirstMethod->getLocation(),
10255  FirstMethod->getSourceRange(), MethodParameterType)
10256  << FirstMethodType << FirstName << (I + 1) << FirstParamType
10257  << false;
10258  }
10259 
10260  if (const DecayedType *ParamDecayedType =
10261  SecondParamType->getAs<DecayedType>()) {
10262  ODRDiagNote(SecondMethod->getLocation(),
10263  SecondMethod->getSourceRange(), MethodParameterType)
10264  << SecondMethodType << SecondName << (I + 1)
10265  << SecondParamType << true
10266  << ParamDecayedType->getOriginalType();
10267  } else {
10268  ODRDiagNote(SecondMethod->getLocation(),
10269  SecondMethod->getSourceRange(), MethodParameterType)
10270  << SecondMethodType << SecondName << (I + 1)
10271  << SecondParamType << false;
10272  }
10273  ParameterMismatch = true;
10274  break;
10275  }
10276 
10277  DeclarationName FirstParamName = FirstParam->getDeclName();
10278  DeclarationName SecondParamName = SecondParam->getDeclName();
10279  if (FirstParamName != SecondParamName) {
10280  ODRDiagError(FirstMethod->getLocation(),
10281  FirstMethod->getSourceRange(), MethodParameterName)
10282  << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10283  ODRDiagNote(SecondMethod->getLocation(),
10284  SecondMethod->getSourceRange(), MethodParameterName)
10285  << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10286  ParameterMismatch = true;
10287  break;
10288  }
10289 
10290  const Expr *FirstInit = FirstParam->getInit();
10291  const Expr *SecondInit = SecondParam->getInit();
10292  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10293  ODRDiagError(FirstMethod->getLocation(),
10294  FirstMethod->getSourceRange(),
10295  MethodParameterSingleDefaultArgument)
10296  << FirstMethodType << FirstName << (I + 1)
10297  << (FirstInit == nullptr)
10298  << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10299  ODRDiagNote(SecondMethod->getLocation(),
10300  SecondMethod->getSourceRange(),
10301  MethodParameterSingleDefaultArgument)
10302  << SecondMethodType << SecondName << (I + 1)
10303  << (SecondInit == nullptr)
10304  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10305  ParameterMismatch = true;
10306  break;
10307  }
10308 
10309  if (FirstInit && SecondInit &&
10310  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10311  ODRDiagError(FirstMethod->getLocation(),
10312  FirstMethod->getSourceRange(),
10313  MethodParameterDifferentDefaultArgument)
10314  << FirstMethodType << FirstName << (I + 1)
10315  << FirstInit->getSourceRange();
10316  ODRDiagNote(SecondMethod->getLocation(),
10317  SecondMethod->getSourceRange(),
10318  MethodParameterDifferentDefaultArgument)
10319  << SecondMethodType << SecondName << (I + 1)
10320  << SecondInit->getSourceRange();
10321  ParameterMismatch = true;
10322  break;
10323 
10324  }
10325  }
10326 
10327  if (ParameterMismatch) {
10328  Diagnosed = true;
10329  break;
10330  }
10331 
10332  break;
10333  }
10334  case TypeAlias:
10335  case TypeDef: {
10336  TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
10337  TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
10338  auto FirstName = FirstTD->getDeclName();
10339  auto SecondName = SecondTD->getDeclName();
10340  if (FirstName != SecondName) {
10341  ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10342  TypedefName)
10343  << (FirstDiffType == TypeAlias) << FirstName;
10344  ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10345  TypedefName)
10346  << (FirstDiffType == TypeAlias) << SecondName;
10347  Diagnosed = true;
10348  break;
10349  }
10350 
10351  QualType FirstType = FirstTD->getUnderlyingType();
10352  QualType SecondType = SecondTD->getUnderlyingType();
10353  if (ComputeQualTypeODRHash(FirstType) !=
10354  ComputeQualTypeODRHash(SecondType)) {
10355  ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10356  TypedefType)
10357  << (FirstDiffType == TypeAlias) << FirstName << FirstType;
10358  ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10359  TypedefType)
10360  << (FirstDiffType == TypeAlias) << SecondName << SecondType;
10361  Diagnosed = true;
10362  break;
10363  }
10364  break;
10365  }
10366  case Var: {
10367  VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
10368  VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
10369  auto FirstName = FirstVD->getDeclName();
10370  auto SecondName = SecondVD->getDeclName();
10371  if (FirstName != SecondName) {
10372  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10373  VarName)
10374  << FirstName;
10375  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10376  VarName)
10377  << SecondName;
10378  Diagnosed = true;
10379  break;
10380  }
10381 
10382  QualType FirstType = FirstVD->getType();
10383  QualType SecondType = SecondVD->getType();
10384  if (ComputeQualTypeODRHash(FirstType) !=
10385  ComputeQualTypeODRHash(SecondType)) {
10386  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10387  VarType)
10388  << FirstName << FirstType;
10389  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10390  VarType)
10391  << SecondName << SecondType;
10392  Diagnosed = true;
10393  break;
10394  }
10395 
10396  const Expr *FirstInit = FirstVD->getInit();
10397  const Expr *SecondInit = SecondVD->getInit();
10398  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10399  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10400  VarSingleInitializer)
10401  << FirstName << (FirstInit == nullptr)
10402  << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
10403  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10404  VarSingleInitializer)
10405  << SecondName << (SecondInit == nullptr)
10406  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10407  Diagnosed = true;
10408  break;
10409  }
10410 
10411  if (FirstInit && SecondInit &&
10412  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10413  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10414  VarDifferentInitializer)
10415  << FirstName << FirstInit->getSourceRange();
10416  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10417  VarDifferentInitializer)
10418  << SecondName << SecondInit->getSourceRange();
10419  Diagnosed = true;
10420  break;
10421  }
10422 
10423  const bool FirstIsConstexpr = FirstVD->isConstexpr();
10424  const bool SecondIsConstexpr = SecondVD->isConstexpr();
10425  if (FirstIsConstexpr != SecondIsConstexpr) {
10426  ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10427  VarConstexpr)
10428  << FirstName << FirstIsConstexpr;
10429  ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10430  VarConstexpr)
10431  << SecondName << SecondIsConstexpr;
10432  Diagnosed = true;
10433  break;
10434  }
10435  break;
10436  }
10437  case Friend: {
10438  FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10439  FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10440 
10441  NamedDecl *FirstND = FirstFriend->getFriendDecl();
10442  NamedDecl *SecondND = SecondFriend->getFriendDecl();
10443 
10444  TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10445  TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10446 
10447  if (FirstND && SecondND) {
10448  ODRDiagError(FirstFriend->getFriendLoc(),
10449  FirstFriend->getSourceRange(), FriendFunction)
10450  << FirstND;
10451  ODRDiagNote(SecondFriend->getFriendLoc(),
10452  SecondFriend->getSourceRange(), FriendFunction)
10453  << SecondND;
10454 
10455  Diagnosed = true;
10456  break;
10457  }
10458 
10459  if (FirstTSI && SecondTSI) {
10460  QualType FirstFriendType = FirstTSI->getType();
10461  QualType SecondFriendType = SecondTSI->getType();
10462  assert(ComputeQualTypeODRHash(FirstFriendType) !=
10463  ComputeQualTypeODRHash(SecondFriendType));
10464  ODRDiagError(FirstFriend->getFriendLoc(),
10465  FirstFriend->getSourceRange(), FriendType)
10466  << FirstFriendType;
10467  ODRDiagNote(SecondFriend->getFriendLoc(),
10468  SecondFriend->getSourceRange(), FriendType)
10469  << SecondFriendType;
10470  Diagnosed = true;
10471  break;
10472  }
10473 
10474  ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10475  FriendTypeFunction)
10476  << (FirstTSI == nullptr);
10477  ODRDiagNote(SecondFriend->getFriendLoc(),
10478  SecondFriend->getSourceRange(), FriendTypeFunction)
10479  << (SecondTSI == nullptr);
10480 
10481  Diagnosed = true;
10482  break;
10483  }
10484  }
10485 
10486  if (Diagnosed)
10487  continue;
10488 
10489  Diag(FirstDecl->getLocation(),
10490  diag::err_module_odr_violation_mismatch_decl_unknown)
10491  << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
10492  << FirstDecl->getSourceRange();
10493  Diag(SecondDecl->getLocation(),
10494  diag::note_module_odr_violation_mismatch_decl_unknown)
10495  << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
10496  Diagnosed = true;
10497  }
10498 
10499  if (!Diagnosed) {
10500  // All definitions are updates to the same declaration. This happens if a
10501  // module instantiates the declaration of a class template specialization
10502  // and two or more other modules instantiate its definition.
10503  //
10504  // FIXME: Indicate which modules had instantiations of this definition.
10505  // FIXME: How can this even happen?
10506  Diag(Merge.first->getLocation(),
10507  diag::err_module_odr_violation_different_instantiations)
10508  << Merge.first;
10509  }
10510  }
10511 
10512  // Issue ODR failures diagnostics for functions.
10513  for (auto &Merge : FunctionOdrMergeFailures) {
10514  enum ODRFunctionDifference {
10515  ReturnType,
10516  ParameterName,
10517  ParameterType,
10518  ParameterSingleDefaultArgument,
10519  ParameterDifferentDefaultArgument,
10520  FunctionBody,
10521  };
10522 
10523  FunctionDecl *FirstFunction = Merge.first;
10524  std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
10525 
10526  bool Diagnosed = false;
10527  for (auto &SecondFunction : Merge.second) {
10528 
10529  if (FirstFunction == SecondFunction)
10530  continue;
10531 
10532  std::string SecondModule =
10533  getOwningModuleNameForDiagnostic(SecondFunction);
10534 
10535  auto ODRDiagError = [FirstFunction, &FirstModule,
10536  this](SourceLocation Loc, SourceRange Range,
10537  ODRFunctionDifference DiffType) {
10538  return Diag(Loc, diag::err_module_odr_violation_function)
10539  << FirstFunction << FirstModule.empty() << FirstModule << Range
10540  << DiffType;
10541  };
10542  auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
10543  SourceRange Range,
10544  ODRFunctionDifference DiffType) {
10545  return Diag(Loc, diag::note_module_odr_violation_function)
10546  << SecondModule << Range << DiffType;
10547  };
10548 
10549  if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
10550  ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
10551  ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
10552  FirstFunction->getReturnTypeSourceRange(), ReturnType)
10553  << FirstFunction->getReturnType();
10554  ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
10555  SecondFunction->getReturnTypeSourceRange(), ReturnType)
10556  << SecondFunction->getReturnType();
10557  Diagnosed = true;
10558  break;
10559  }
10560 
10561  assert(FirstFunction->param_size() == SecondFunction->param_size() &&
10562  "Merged functions with different number of parameters");
10563 
10564  auto ParamSize = FirstFunction->param_size();
10565  bool ParameterMismatch = false;
10566  for (unsigned I = 0; I < ParamSize; ++I) {
10567  auto *FirstParam = FirstFunction->getParamDecl(I);
10568  auto *SecondParam = SecondFunction->getParamDecl(I);
10569 
10570  assert(getContext().hasSameType(FirstParam->getType(),
10571  SecondParam->getType()) &&
10572  "Merged function has different parameter types.");
10573 
10574  if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
10575  ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
10576  ParameterName)
10577  << I + 1 << FirstParam->getDeclName();
10578  ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
10579  ParameterName)
10580  << I + 1 << SecondParam->getDeclName();
10581  ParameterMismatch = true;
10582  break;
10583  };
10584 
10585  QualType FirstParamType = FirstParam->getType();
10586  QualType SecondParamType = SecondParam->getType();
10587  if (FirstParamType != SecondParamType &&
10588  ComputeQualTypeODRHash(FirstParamType) !=
10589  ComputeQualTypeODRHash(SecondParamType)) {
10590  if (const DecayedType *ParamDecayedType =
10591  FirstParamType->getAs<DecayedType>()) {
10592  ODRDiagError(FirstParam->getLocation(),
10593  FirstParam->getSourceRange(), ParameterType)
10594  << (I + 1) << FirstParamType << true
10595  << ParamDecayedType->getOriginalType();
10596  } else {
10597  ODRDiagError(FirstParam->getLocation(),
10598  FirstParam->getSourceRange(), ParameterType)
10599  << (I + 1) << FirstParamType << false;
10600  }
10601 
10602  if (const DecayedType *ParamDecayedType =
10603  SecondParamType->getAs<DecayedType>()) {
10604  ODRDiagNote(SecondParam->getLocation(),
10605  SecondParam->getSourceRange(), ParameterType)
10606  << (I + 1) << SecondParamType << true
10607  << ParamDecayedType->getOriginalType();
10608  } else {
10609  ODRDiagNote(SecondParam->getLocation(),
10610  SecondParam->getSourceRange(), ParameterType)
10611  << (I + 1) << SecondParamType << false;
10612  }
10613  ParameterMismatch = true;
10614  break;
10615  }
10616 
10617  const Expr *FirstInit = FirstParam->getInit();
10618  const Expr *SecondInit = SecondParam->getInit();
10619  if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10620  ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
10621  ParameterSingleDefaultArgument)
10622  << (I + 1) << (FirstInit == nullptr)
10623  << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10624  ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
10625  ParameterSingleDefaultArgument)
10626  << (I + 1) << (SecondInit == nullptr)
10627  << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10628  ParameterMismatch = true;
10629  break;
10630  }
10631 
10632  if (FirstInit && SecondInit &&
10633  ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10634  ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
10635  ParameterDifferentDefaultArgument)
10636  << (I + 1) << FirstInit->getSourceRange();
10637  ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
10638  ParameterDifferentDefaultArgument)
10639  << (I + 1) << SecondInit->getSourceRange();
10640  ParameterMismatch = true;
10641  break;
10642  }
10643 
10644  assert(ComputeSubDeclODRHash(FirstParam) ==
10645  ComputeSubDeclODRHash(SecondParam) &&
10646  "Undiagnosed parameter difference.");
10647  }
10648 
10649  if (ParameterMismatch) {
10650  Diagnosed = true;
10651  break;
10652  }
10653 
10654  // If no error has been generated before now, assume the problem is in
10655  // the body and generate a message.
10656  ODRDiagError(FirstFunction->getLocation(),
10657  FirstFunction->getSourceRange(), FunctionBody);
10658  ODRDiagNote(SecondFunction->getLocation(),
10659  SecondFunction->getSourceRange(), FunctionBody);
10660  Diagnosed = true;
10661  break;
10662  }
10663  assert(Diagnosed && "Unable to emit ODR diagnostic.");
10664  }
10665 }
10666 
10668  if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
10669  ReadTimer->startTimer();
10670 }
10671 
10673  assert(NumCurrentElementsDeserializing &&
10674  "FinishedDeserializing not paired with StartedDeserializing");
10675  if (NumCurrentElementsDeserializing == 1) {
10676  // We decrease NumCurrentElementsDeserializing only after pending actions
10677  // are finished, to avoid recursively re-calling finishPendingActions().
10678  finishPendingActions();
10679  }
10680  --NumCurrentElementsDeserializing;
10681 
10682  if (NumCurrentElementsDeserializing == 0) {
10683  // Propagate exception specification updates along redeclaration chains.
10684  while (!PendingExceptionSpecUpdates.empty()) {
10685  auto Updates = std::move(PendingExceptionSpecUpdates);
10686  PendingExceptionSpecUpdates.clear();
10687  for (auto Update : Updates) {
10688  ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
10689  auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
10690  auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
10691  if (auto *Listener = getContext().getASTMutationListener())
10692  Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
10693  for (auto *Redecl : Update.second->redecls())
10694  getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
10695  }
10696  }
10697 
10698  if (ReadTimer)
10699  ReadTimer->stopTimer();
10700 
10701  diagnoseOdrViolations();
10702 
10703  // We are not in recursive loading, so it's safe to pass the "interesting"
10704  // decls to the consumer.
10705  if (Consumer)
10706  PassInterestingDeclsToConsumer();
10707  }
10708 }
10709 
10710 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
10711  if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
10712  // Remove any fake results before adding any real ones.
10713  auto It = PendingFakeLookupResults.find(II);
10714  if (It != PendingFakeLookupResults.end()) {
10715  for (auto *ND : It->second)
10716  SemaObj->IdResolver.RemoveDecl(ND);
10717  // FIXME: this works around module+PCH performance issue.
10718  // Rather than erase the result from the map, which is O(n), just clear
10719  // the vector of NamedDecls.
10720  It->second.clear();
10721  }
10722  }
10723 
10724  if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
10725  SemaObj->TUScope->AddDecl(D);
10726  } else if (SemaObj->TUScope) {
10727  // Adding the decl to IdResolver may have failed because it was already in
10728  // (even though it was not added in scope). If it is already in, make sure
10729  // it gets in the scope as well.
10730  if (std::find(SemaObj->IdResolver.begin(Name),
10731  SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
10732  SemaObj->TUScope->AddDecl(D);
10733  }
10734 }
10735 
10737  const PCHContainerReader &PCHContainerRdr,
10738  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
10739  StringRef isysroot, bool DisableValidation,
10740  bool AllowASTWithCompilerErrors,
10741  bool AllowConfigurationMismatch, bool ValidateSystemInputs,
10742  bool UseGlobalIndex,
10743  std::unique_ptr<llvm::Timer> ReadTimer)
10744  : Listener(DisableValidation
10746  : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
10747  SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
10748  PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
10749  ContextObj(Context),
10750  ModuleMgr(PP.getFileManager(), PP.getPCMCache(), PCHContainerRdr,
10751  PP.getHeaderSearchInfo()),
10752  PCMCache(PP.getPCMCache()), DummyIdResolver(PP),
10753  ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
10754  DisableValidation(DisableValidation),
10755  AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
10756  AllowConfigurationMismatch(AllowConfigurationMismatch),
10757  ValidateSystemInputs(ValidateSystemInputs),
10758  UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
10759  SourceMgr.setExternalSLocEntrySource(this);
10760 
10761  for (const auto &Ext : Extensions) {
10762  auto BlockName = Ext->getExtensionMetadata().BlockName;
10763  auto Known = ModuleFileExtensions.find(BlockName);
10764  if (Known != ModuleFileExtensions.end()) {
10765  Diags.Report(diag::warn_duplicate_module_file_extension)
10766  << BlockName;
10767  continue;
10768  }
10769 
10770  ModuleFileExtensions.insert({BlockName, Ext});
10771  }
10772 }
10773 
10775  if (OwnsDeserializationListener)
10776  delete DeserializationListener;
10777 }
10778 
10780  return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
10781 }
10782 
10783 unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
10784  unsigned AbbrevID) {
10785  Idx = 0;
10786  Record.clear();
10787  return Cursor.readRecord(AbbrevID, Record);
10788 }
llvm::APInt ReadAPInt(const RecordData &Record, unsigned &Idx)
Read an integral value.
Definition: ASTReader.cpp:8907
Decl * GetExistingDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration.
Definition: ASTReader.cpp:7168
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:210
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.
void setSourceOrder(int Pos)
Set the source order of this initializer.
Definition: DeclCXX.h:2352
Defines the clang::ASTContext interface.
The ObjC &#39;SEL&#39; type.
Definition: ASTBitCodes.h:867
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:4901
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:7960
bool FindExternalVisibleDeclsByName(const DeclContext *DC, DeclarationName Name) override
Finds all the visible declarations with a given name.
Definition: ASTReader.cpp:7380
ASTReadResult
The result of reading the control block of an AST file, which can fail for various reasons...
Definition: ASTReader.h:384
Record code for the preprocessor options table.
Definition: ASTBitCodes.h:339
std::vector< unsigned > PreloadIdentifierOffsets
Offsets of identifiers that we&#39;re going to preload within IdentifierTableData.
Definition: Module.h:281
SmallVector< UnresolvedExportDecl, 2 > UnresolvedExports
The set of export declarations that have yet to be resolved.
Definition: Module.h:302
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
CanQualType LongLongTy
Definition: ASTContext.h:1004
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:1502
void setInfo(const DeclarationNameLoc &Info)
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
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:1671
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:7826
void * IdentifierLookupTable
A pointer to an on-disk hash table of opaque type IdentifierHashTable.
Definition: Module.h:277
void setjmp_bufDecl(TypeDecl *jmp_bufDecl)
Set the type for the C jmp_buf type.
Definition: ASTContext.h:1700
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:191
CanQualType OCLQueueTy
Definition: ASTContext.h:1022
Record code for potentially unused local typedef names.
Definition: ASTBitCodes.h:600
Record code for map of Objective-C class definition IDs to the ObjC categories in a module that are a...
Definition: ASTBitCodes.h:558
Smart pointer class that efficiently represents Objective-C method names.
static void updateModuleTimestamp(ModuleFile &MF)
Definition: ASTReader.cpp:3792
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:802
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:368
A (possibly-)qualified type.
Definition: Type.h:653
static LLVM_DUMP_METHOD void dumpModuleIDMap(StringRef Name, const ContinuousRangeMap< Key, ModuleFile *, InitialCapacity > &Map)
Definition: ASTReader.cpp:7562
A PointerType record.
Definition: ASTBitCodes.h:944
virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines)
Receives the preprocessor options.
Definition: ASTReader.h:199
static void addMethodsToPool(Sema &S, ArrayRef< ObjCMethodDecl *> Methods, ObjCMethodList &List)
Add the given set of methods to the method list.
Definition: ASTReader.cpp:7916
void * getAsOpaquePtr() const
CtorInitializerType
The different kinds of data that can occur in a CtorInitializer.
Definition: ASTBitCodes.h:1887
The &#39;_Float16&#39; type.
Definition: ASTBitCodes.h:915
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:676
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:26
static bool startsWithASTFileMagic(BitstreamCursor &Stream)
Whether Stream starts with the AST/PCH file magic number &#39;CPCH&#39;.
Definition: ASTReader.cpp:4072
void SetIdentifierInfo(unsigned ID, IdentifierInfo *II)
Definition: ASTReader.cpp:8146
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:227
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:801
The (signed) &#39;long long&#39; type.
Definition: ASTBitCodes.h:828
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:34
virtual void visitModuleFile(StringRef Filename, serialization::ModuleKind Kind)
This is called for each AST file loaded.
Definition: ASTReader.h:210
A simple structure that captures a vtable use for the purposes of the ExternalSemaSource.
SourceManager & getSourceManager() const
Definition: ASTReader.h:1479
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...
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:7034
Record code for the source manager line table information, which stores information about #line direc...
Definition: ASTBitCodes.h:554
virtual StringRef ExtractPCH(llvm::MemoryBufferRef Buffer) const =0
Returns the serialized AST inside the PCH container Buffer.
SourceRange getBraceRange() const
Definition: Decl.h:3072
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:115
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:789
std::string ModuleUserBuildPath
The directory used for a user build.
CanQualType Char32Ty
Definition: ASTContext.h:1003
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:2334
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:928
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Definition: Type.h:1314
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:5596
Expr * getBitWidth() const
Definition: Decl.h:2556
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1637
const FileEntry * getFile() const
Definition: Module.h:87
bool getEnableAllWarnings() const
Definition: Diagnostic.h:517
void AddQualType(QualType T)
Definition: ODRHash.cpp:726
void setExceptionSpecRange(SourceRange R)
Definition: TypeLoc.h:1457
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:101
SourceLocation DirectImportLoc
The source location where the module was explicitly or implicitly imported in the local translation u...
Definition: Module.h:191
unsigned IsExternC
Whether this is an &#39;extern "C"&#39; module (which implicitly puts all headers in it within an &#39;extern "C"...
Definition: Module.h:228
ControlRecordTypes
Record types that occur within the control block.
Definition: ASTBitCodes.h:282
void addTopHeaderFilename(StringRef Filename)
Add a top-level header filename associated with this module.
Definition: Module.h:484
llvm::MemoryBuffer * Buffer
The memory buffer that stores the data associated with this AST file, owned by the PCMCache in the Mo...
Definition: Module.h:168
unsigned Generation
The generation of which this module file is a part.
Definition: Module.h:164
void ReadComments() override
Loads comments ranges.
Definition: ASTReader.cpp:8994
std::vector< UnresolvedConflict > UnresolvedConflicts
The list of conflicts for which the module-id has not yet been resolved.
Definition: Module.h:346
C Language Family Type Representation.
Defines the SourceManager interface.
The &#39;unknown any&#39; placeholder type.
Definition: ASTBitCodes.h:870
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...
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
Definition: ASTContext.h:1724
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the target options.
Definition: ASTReader.cpp:169
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:705
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:8313
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, uint32_t Raw) const
Read a source location from raw form.
Definition: ASTReader.h:2156
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1880
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:246
Module * getCurrentModule()
Retrieves the module that we&#39;re currently building, if any.
TagDecl * getDecl() const
Definition: Type.cpp:3037
CanQualType ObjCBuiltinSelTy
Definition: ASTContext.h:1016
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:7336
Selector getObjCSelector() const
getObjCSelector - Get the Objective-C selector stored in this declaration name.
void VisitFunctionTypeLoc(FunctionTypeLoc)
Definition: ASTReader.cpp:6498
ModuleKind Kind
The type of this module.
Definition: Module.h:112
virtual void ReadCounter(const serialization::ModuleFile &M, unsigned Value)
Receives COUNTER value.
Definition: ASTReader.h:206
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:654
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:622
void ReadDelegatingConstructors(SmallVectorImpl< CXXConstructorDecl *> &Decls) override
Read the set of delegating constructors known to the external Sema source.
Definition: ASTReader.cpp:8022
An LValueReferenceType record.
Definition: ASTBitCodes.h:950
The placeholder type for builtin functions.
Definition: ASTBitCodes.h:891
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:448
Defines types useful for describing an Objective-C runtime.
Specifies the submodules that are imported by this submodule.
Definition: ASTBitCodes.h:720
std::string ModuleName
The name of the module.
Definition: Module.h:118
void ReadTentativeDefinitions(SmallVectorImpl< VarDecl *> &TentativeDefs) override
Read the set of tentative definitions known to the external Sema source.
Definition: ASTReader.cpp:8001
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:1015
A record that stores the set of declarations that are lexically stored within a given DeclContext...
Definition: ASTBitCodes.h:1279
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:716
The base class of the type hierarchy.
Definition: Type.h:1351
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:8238
CanQualType LongTy
Definition: ASTContext.h:1004
DiagnosticsEngine & getDiagnostics() const
unsigned LocalNumObjCCategoriesInMap
The number of redeclaration info entries in ObjCCategoriesMap.
Definition: Module.h:420
void setHasLineDirectives()
Set the flag that indicates that this FileID has line table entries associated with it...
StringRef getOriginalSourceFile()
Retrieve the name of the original source file name for the primary module file.
Definition: ASTReader.h:1645
#define CHECK_TARGET_OPT(Field, Name)
A SubstTemplateTypeParmType record.
Definition: ASTBitCodes.h:1007
Decl * GetDecl(serialization::DeclID ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: ASTReader.cpp:7193
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1207
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2153
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
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
Wrapper for source info for typedefs.
Definition: TypeLoc.h:665
static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II)
Definition: ASTReader.cpp:915
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:95
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:174
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:1911
Record code for enabled OpenCL extensions.
Definition: ASTBitCodes.h:537
Record code for the module build directory.
Definition: ASTBitCodes.h:315
Floating point control options.
Definition: LangOptions.h:208
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:1645
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:3694
An ElaboratedType record.
Definition: ASTBitCodes.h:1004
serialization::SelectorID BaseSelectorID
Base selector ID for selectors local to this module.
Definition: Module.h:365
An UnresolvedUsingType record.
Definition: ASTBitCodes.h:1010
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
bool getSuppressSystemWarnings() const
Definition: Diagnostic.h:541
Wrapper for source info for pointers decayed from arrays and functions.
Definition: TypeLoc.h:1232
ASTFileSignature Signature
The signature of the module file, which may be used instead of the size and modification time to iden...
Definition: Module.h:157
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
Definition: DeclBase.h:1899
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:2397
An IncompleteArrayType record.
Definition: ASTBitCodes.h:962
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:1166
diag::Severity getExtensionHandlingBehavior() const
Definition: Diagnostic.h:603
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:1799
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:1991
Specifies a header that is part of the module but must be textually included.
Definition: ASTBitCodes.h:747
const uint32_t * SLocEntryOffsets
Offsets for all of the source location entries in the AST file.
Definition: Module.h:243
size_t param_size() const
Definition: Decl.h:2183
bool RelocatablePCH
Whether this precompiled header is a relocatable PCH file.
Definition: Module.h:147
CXXBaseSpecifier ReadCXXBaseSpecifier(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a C++ base specifier.
Definition: ASTReader.cpp:8698
ARC&#39;s unbridged-cast placeholder type.
Definition: ASTBitCodes.h:885
CanQualType HalfTy
Definition: ASTContext.h:1008
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:1498
The &#39;__int128_t&#39; type.
Definition: ASTBitCodes.h:849
The AST file has errors.
Definition: ASTReader.h:407
QualType withFastQualifiers(unsigned TQs) const
Definition: Type.h:861
The C++ &#39;char32_t&#39; type.
Definition: ASTBitCodes.h:858
An identifier, stored as an IdentifierInfo*.
The internal &#39;__builtin_va_list&#39; typedef.
Definition: ASTBitCodes.h:1145
The stack of open #ifs/#ifdefs recorded in a preamble.
Definition: ASTBitCodes.h:629
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:232
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:258
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
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:626
A block with unhashed content.
Definition: ASTBitCodes.h:278
QualType getReturnType() const
Definition: Decl.h:2207
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:7015
Wrapper for source info for member pointers.
Definition: TypeLoc.h:1301
void VisitArrayTypeLoc(ArrayTypeLoc)
Definition: ASTReader.cpp:6448
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:6305
Record code for declarations associated with OpenCL extensions.
Definition: ASTBitCodes.h:621
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:6962
CanQualType Float128Ty
Definition: ASTContext.h:1007
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:3387
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1580
void InitializeSema(Sema &S) override
Initialize the semantic source with the Sema instance being used to perform semantic analysis on the ...
Definition: ASTReader.cpp:7614
serialization::SubmoduleID BaseSubmoduleID
Base submodule ID for submodules local to this module.
Definition: Module.h:348
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
Definition: ASTBitCodes.h:1173
The value of the next COUNTER to dispense.
Definition: ASTBitCodes.h:462
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:707
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:595
A namespace, stored as a NamespaceDecl*.
void ReadReferencedSelectors(SmallVectorImpl< std::pair< Selector, SourceLocation >> &Sels) override
Definition: ASTReader.cpp:8055
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:531
data_type ReadData(Selector, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:838
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:640
Used to hold and unique data used to represent #line information.
Record code for the target options table.
Definition: ASTBitCodes.h:330
static StringRef bytes(const std::vector< T, Allocator > &v)
Definition: ASTWriter.cpp:119
void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override
Receives COUNTER value.
Definition: ASTReader.cpp:788
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:433
std::string PresumedModuleMapFile
The presumed file name for the module map defining this module.
Definition: Module.h:100
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
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:236
ContinuousRangeMap< uint32_t, int, 2 > DeclRemap
Remapping table for declaration IDs in this module.
Definition: Module.h:400
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2014
The collection of all-type qualifiers we support.
Definition: Type.h:152
void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo)
Definition: TypeLoc.h:1027
void clear()
Definition: ODRHash.cpp:170
SourceLocation ImportLoc
The source location where this module was first imported.
Definition: Module.h:194
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:195
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:1494
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:3057
CanQualType OCLSamplerTy
Definition: ASTContext.h:1021
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
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:7976
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:205
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
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
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
Selector getUnarySelector(IdentifierInfo *ID)
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
static bool isWhitelistedDecl(const Decl *D, const CXXRecordDecl *Record)
Definition: ODRHash.cpp:398
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3388
One of these records is kept for each identifier that is lexed.
A macro directive exported by a module.
Definition: ASTBitCodes.h:680
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:178
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:713
std::string ActualOriginalSourceFileName
The actual original source file name that was used to build this AST file.
Definition: Module.h:134
The block containing comments.
Definition: ASTBitCodes.h:251
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:2006
The Objective-C &#39;SEL&#39; type.
Definition: ASTBitCodes.h:1127
StringLiteral * getMessage()
Definition: DeclCXX.h:3695
A library or framework to link against when an entity from this module is used.
Definition: Module.h:312
void finalizeForWriting()
Finalizes the AST reader&#39;s state before writing an AST file to disk.
Definition: ASTReader.cpp:4558
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:531
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:713
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
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:810
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:1321
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
The &#39;unsigned long&#39; type.
Definition: ASTBitCodes.h:804
Specifies a header that has been explicitly excluded from this submodule.
Definition: ASTBitCodes.h:731
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
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
bool isVolatile() const
Definition: DeclCXX.h:2007
bool isCPlusPlusOperatorKeyword() const
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
Definition: Format.h:1900
ContinuousRangeMap< uint32_t, int, 2 > PreprocessedEntityRemap
Remapping table for preprocessed entity IDs in this module.
Definition: Module.h:322
Record code for the module map file that was used to build this AST file.
Definition: ASTBitCodes.h:312
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:772
An ExtVectorType record.
Definition: ASTBitCodes.h:971
Delete expressions that will be analyzed later.
Definition: ASTBitCodes.h:605
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.
method_range methods() const
Definition: DeclObjC.h:1055
Helper class that saves the current stream position and then restores it when destroyed.
Definition: ASTReader.h:2619
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Module.h:465
void setName(DeclarationName N)
setName - Sets the embedded declaration name.
CanQualType OCLEventTy
Definition: ASTContext.h:1021
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3289
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:2064
TemplateName ReadTemplateName(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a template name.
Definition: ASTReader.cpp:8542
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:404
The fast qualifier mask.
Definition: Type.h:198
virtual bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences)
Receives the language options.
Definition: ASTReader.h:147
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:71
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
DeclarationName getCXXDestructorName(CanQualType Ty)
getCXXDestructorName - Returns the name of a C++ destructor for the given Type.
void setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir, Twine NameAsWritten)
Sets the umbrella directory of the given module to the given directory.
Definition: ModuleMap.cpp:1014
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:142
void setKind(tok::TokenKind K)
Definition: Token.h:91
TypeLoc getNextTypeLoc() const
Definition: TypeLoc.h:400
An AttributedType record.
Definition: ASTBitCodes.h:1040
uint32_t MacroID
An ID number that refers to a macro in an AST file.
Definition: ASTBitCodes.h:141
An object-like macro definition.
Definition: ASTBitCodes.h:664
void setUnderlyingTInfo(TypeSourceInfo *TInfo)
Definition: TypeLoc.h:1947
The client can handle an AST file that cannot load because it&#39;s compiled configuration doesn&#39;t match ...
Definition: ASTReader.h:1507
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1022
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:48
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:815
Describes one token.
Definition: ASTBitCodes.h:673
internal_key_type ReadKey(const unsigned char *d, unsigned)
Definition: ASTReader.cpp:816
An AdjustedType record.
Definition: ASTBitCodes.h:1058
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...
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:3834
void completeVisibleDeclsMap(const DeclContext *DC) override
Load all external visible decls in the given DeclContext.
Definition: ASTReader.cpp:7406
unsigned LocalNumHeaderFileInfos
The number of local HeaderFileInfo structures.
Definition: Module.h:330
Record code for the set of ext_vector type names.
Definition: ASTBitCodes.h:477
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Definition: ASTReader.cpp:8943
llvm::Optional< ASTSourceDescriptor > getSourceDescriptor(unsigned ID) override
Return a descriptor for the corresponding module.
Definition: ASTReader.cpp:8362
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:580
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:443
bool isInvalid() const
const PPEntityOffset * PreprocessedEntityOffsets
Definition: Module.h:324
Specifies the submodules that are re-exported from this submodule.
Definition: ASTBitCodes.h:724
void setProtocolLoc(unsigned i, SourceLocation Loc)
Definition: TypeLoc.h:796
TemplateParameterList ** TemplParamLists
TemplParamLists - A new-allocated array of size NumTemplParamLists, containing pointers to the "outer...
Definition: Decl.h:666
std::string UserInfo
A string containing additional user information that will be stored with the metadata.
serialization::MacroID BaseMacroID
Base macro ID for macros local to this module.
Definition: Module.h:300
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2545
Selector getNullarySelector(IdentifierInfo *ID)
The Objective-C &#39;id&#39; type.
Definition: ASTBitCodes.h:1124
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:2290
unsigned InferExportWildcard
Whether, when inferring submodules, the inferr submodules should export all modules they import (e...
Definition: Module.h:245
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:5390
void setCaretLoc(SourceLocation Loc)
Definition: TypeLoc.h:1291
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2177
Wrapper for source info for injected class names of class templates.
Definition: TypeLoc.h:676
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:6690
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:821
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:1108
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
void setcudaConfigureCallDecl(FunctionDecl *FD)
Definition: ASTContext.h:1233
uint32_t Offset
Definition: CacheTokens.cpp:43
Describes a blob that contains the data for a buffer entry.
Definition: ASTBitCodes.h:646
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:327
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined &#39;SEL&#39; type in Objective-C.
void ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8528
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:354
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:7061
Wrapper for source info for functions.
Definition: TypeLoc.h:1396
Specifies a conflict with another module.
Definition: ASTBitCodes.h:740
The signed 128-bit integer type.
Definition: ASTBitCodes.h:1136
unsigned getHash() const
Compute a fingerprint of this key for use in on-disk hash table.
Definition: ASTReader.cpp:1040
CXXCtorInitializer ** ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a CXXCtorInitializer array.
Definition: ASTReader.cpp:8714
llvm::APSInt ReadAPSInt(const RecordData &Record, unsigned &Idx)
Read a signed integral value.
Definition: ASTReader.cpp:8916
A UnaryTransformType record.
Definition: ASTBitCodes.h:1049
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:7260
An ObjCObjectType record.
Definition: ASTBitCodes.h:1016
A ConstantArrayType record.
Definition: ASTBitCodes.h:959
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8936
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:733
llvm::iterator_range< ModuleDeclIterator > getModuleFileLevelDecls(ModuleFile &Mod)
Definition: ASTReader.cpp:5383
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:9078
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID)
Retrieve the global submodule ID given a module and its local ID number.
Definition: ASTReader.cpp:8298
Record code for #pragma optimize options.
Definition: ASTBitCodes.h:597
uint32_t BitOffset
Offset in the AST file.
Definition: ASTBitCodes.h:186
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8955
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:1122
StringRef Data
The serialized bitstream data for this file.
Definition: Module.h:177
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
Specifies a header that is private to this submodule but must be textually included.
Definition: ASTBitCodes.h:751
Record code for pending implicit instantiations.
Definition: ASTBitCodes.h:507
Wrapper for substituted template type parameters.
Definition: TypeLoc.h:832
ExtKind hasExternalDefinitions(const Decl *D) override
Definition: ASTReader.cpp:8379
CanQualType PseudoObjectTy
Definition: ASTContext.h:1015
The internal &#39;__make_integer_seq&#39; template.
Definition: ASTBitCodes.h:1157
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1858
void setLazyBody(uint64_t Offset)
Definition: DeclObjC.h:529
TemplateArgument ReadTemplateArgument(ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument.
Definition: ASTReader.cpp:8601
const TemplateArgument & getArg(unsigned Idx) const
Definition: TemplateBase.h:688
An ExtQualType record.
Definition: ASTBitCodes.h:938
bool isNull() const
Definition: TypeLoc.h:118
Record code for floating point #pragma options.
Definition: ASTBitCodes.h:534
CommentRecordTypes
Record types used within a comments block.
Definition: ASTBitCodes.h:763
Defines the Diagnostic-related interfaces.
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1366
static internal_key_type ReadKey(const unsigned char *d, unsigned n)
Definition: ASTReader.cpp:886
CanQualType LongDoubleTy
Definition: ASTContext.h:1007
void setMustBuildLookupTable()
Mark that there are external lexical declarations that we need to include in our lookup table (and th...
Definition: DeclBase.h:1874
void addExternalSource(ExternalSemaSource *E)
Registers an external source.
Definition: Sema.cpp:399
unsigned IsFromModuleFile
Whether this module was loaded from a module file.
Definition: Module.h:213
std::string OriginalSourceFileName
The original source file name that was used to build the primary AST file, which may have been modifi...
Definition: Module.h:130
Wrapper for source info for ObjC interfaces.
Definition: TypeLoc.h:1118
Record code for the set of known namespaces, which are used for typo correction.
Definition: ASTBitCodes.h:544
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5718
static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps)
Definition: ASTReader.cpp:2229
const serialization::reader::DeclContextLookupTable * getLoadedLookupTables(DeclContext *Primary) const
Get the loaded lookup tables for Primary, if any.
Definition: ASTReader.cpp:7430
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:565
The &#39;unsigned short&#39; type.
Definition: ASTBitCodes.h:798
serialization::DeclID BaseDeclID
Base declaration ID for declarations local to this module.
Definition: Module.h:397
Present this diagnostic as an error.
SourceLocation FirstLoc
The first source location in this module.
Definition: Module.h:197
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:820
A BlockPointerType record.
Definition: ASTBitCodes.h:947
void setProtocolLoc(unsigned i, SourceLocation Loc)
Definition: TypeLoc.h:1057
A MemberPointerType record.
Definition: ASTBitCodes.h:956
ContinuousRangeMap< uint32_t, int, 2 > SLocRemap
Remapping table for source locations in this module.
Definition: Module.h:249
unsigned DisableModuleHash
Whether we should disable the use of the hash string within the module cache.
void ReadWeakUndeclaredIdentifiers(SmallVectorImpl< std::pair< IdentifierInfo *, WeakInfo >> &WI) override
Definition: ASTReader.cpp:8073
void setLocalRangeBegin(SourceLocation L)
Definition: TypeLoc.h:1419
void ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag)
Definition: ASTReader.cpp:5655
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
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:3702
The AST file itself appears corrupted.
Definition: ASTReader.h:390
void dump()
Dump information about the AST reader to standard error.
Definition: ASTReader.cpp:7578
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition: Type.h:3375
void ReadMismatchingDeleteExpressions(llvm::MapVector< FieldDecl *, llvm::SmallVector< std::pair< SourceLocation, bool >, 4 >> &Exprs) override
Definition: ASTReader.cpp:7986
static ASTFileSignature readASTFileSignature(StringRef PCH)
Reads and return the signature record from PCH&#39;s control block, or else returns 0.
Definition: ASTReader.cpp:4564
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:1070
The type of &#39;nullptr&#39;.
Definition: ASTBitCodes.h:852
uint64_t PreprocessorDetailStartOffset
The offset of the start of the preprocessor detail cursor.
Definition: Module.h:315
CanQualType UnsignedCharTy
Definition: ASTContext.h:1005
Record code for the table of offsets into the block of source-location information.
Definition: ASTBitCodes.h:466
void setAttrNameLoc(SourceLocation loc)
Definition: TypeLoc.h:1738
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:869
void setKWLoc(SourceLocation Loc)
Definition: TypeLoc.h:1935
virtual bool needsInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the input files of the AST file via visitInpu...
Definition: ASTReader.h:215
A SubstTemplateTypeParmPackType record.
Definition: ASTBitCodes.h:1043
static std::string ReadString(const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8929
TypeCode
Record codes for each kind of type.
Definition: ASTBitCodes.h:936
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:176
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:137
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1536
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:280
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Module.h:223
The block containing information about the source manager.
Definition: ASTBitCodes.h:234
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:909
A VariableArrayType record.
Definition: ASTBitCodes.h:965
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:1985
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:274
const unsigned int NUM_PREDEF_PP_ENTITY_IDS
The number of predefined preprocessed entity IDs.
Definition: ASTBitCodes.h:223
StringRef getString() const
Definition: Expr.h:1557
void setUsedForHeaderGuard(bool Val)
Definition: MacroInfo.h:274
ASTRecordTypes
Record types that occur within the AST block itself.
Definition: ASTBitCodes.h:371
HashTableTy::const_iterator iterator
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:955
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:4349
Stmt * GetExternalDeclStmt(uint64_t Offset) override
Resolve the offset of a statement into a statement.
Definition: ASTReader.cpp:7247
unsigned NumTemplParamLists
NumTemplParamLists - The number of "outer" template parameter lists.
Definition: Decl.h:659
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
Defines the major attributes of a submodule, including its name and parent.
Definition: ASTBitCodes.h:703
llvm::BitstreamCursor Stream
The main bitstream cursor for the main block.
Definition: Module.h:180
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:131
The &#39;__uint128_t&#39; type.
Definition: ASTBitCodes.h:846
llvm::DenseMap< ModuleFile *, serialization::DeclID > GlobalToLocalDeclIDs
Mapping from the module files that this module file depends on to the base declaration ID for that mo...
Definition: Module.h:409
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:234
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
ModuleHeaderRole
Flags describing the role of a module header.
Definition: ModuleMap.h:106
ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, unsigned PriorGeneration)
Definition: ASTReader.cpp:7854
ModuleKind
Specifies the kind of module that has been loaded.
Definition: Module.h:47
StringRef Filename
Definition: Format.cpp:1345
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:540
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:2564
void ReadModuleMapFile(StringRef ModuleMapPath) override
Definition: ASTReader.cpp:154
void setSizeExpr(Expr *Size)
Definition: TypeLoc.h:1558
unsigned LocalNumSLocEntries
The number of source location entries in this AST file.
Definition: Module.h:233
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:2185
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:9050
ArrayRef< ObjCMethodDecl * > getInstanceMethods() const
Retrieve the instance methods found by this visitor.
Definition: ASTReader.cpp:7893
Record code for the table of offsets of each macro ID.
Definition: ASTBitCodes.h:582
const DirectoryEntry * Entry
Definition: Module.h:162
const uint32_t * TypeOffsets
Offset of each type within the bitstream, indexed by the type ID, or the representation of a Type*...
Definition: Module.h:433
void resolvePendingMacro(IdentifierInfo *II, const PendingMacroInfo &PMInfo)
Definition: ASTReader.cpp:1946
void setAttrNameLoc(SourceLocation loc)
Definition: TypeLoc.h:900
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2161
static NestedNameSpecifier * SuperSpecifier(const ASTContext &Context, CXXRecordDecl *RD)
Returns the nested name specifier representing the __super scope for the given CXXRecordDecl.
A record containing CXXBaseSpecifiers.
Definition: ASTBitCodes.h:1393
void setAttrExprOperand(Expr *e)
Definition: TypeLoc.h:911
DiagnosticBuilder Diag(unsigned DiagID) const
Report a diagnostic.
Definition: ASTReader.cpp:8962
ASTReaderListener implementation to validate the information of the PCH file against an initialized P...
Definition: ASTReader.h:291
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:190
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:140
Specifies some declarations with initializers that must be emitted to initialize the module...
Definition: ASTBitCodes.h:755
An TemplateSpecializationType record.
Definition: ASTBitCodes.h:1022
An ObjCObjectPointerType record.
Definition: ASTBitCodes.h:998
File is from a prebuilt module path.
Definition: Module.h:53
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:6878
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2241
Type source information for an attributed type.
Definition: TypeLoc.h:859
An ObjCInterfaceType record.
Definition: ASTBitCodes.h:995
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:2133
HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE) override
Read the header file information for the given file entry.
Definition: ASTReader.cpp:5646
Describes a zlib-compressed blob that contains the data for a buffer entry.
Definition: ASTBitCodes.h:650
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:627
Expr - This represents one expression.
Definition: Expr.h:106
unsigned getModuleFileID(ModuleFile *M)
Get an ID for the given module file.
Definition: ASTReader.cpp:8344
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:487
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:792
void setHasCommaPasting()
Definition: MacroInfo.h:219
static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II, bool IsModule)
Whether the given identifier is "interesting".
Definition: ASTReader.cpp:892
static InputFile getNotFound()
Definition: Module.h:81
void setModeAttr(bool written)
Definition: TypeLoc.h:647
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTReader.cpp:8985
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:8283
The directory that the PCH was originally created in.
Definition: ASTBitCodes.h:297
int Id
Definition: ASTDiff.cpp:191
const FunctionProtoType * T
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:254
void ReadUsedVTables(SmallVectorImpl< ExternalVTableUse > &VTables) override
Read the set of used vtables known to the external Sema source.
Definition: ASTReader.cpp:8093
The placeholder type for overloaded function sets.
Definition: ASTBitCodes.h:840
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
Definition: LangOptions.h:151
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:4705
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:241
Inits[]
Definition: OpenMPClause.h:140
unsigned ConfigMacrosExhaustive
Whether the set of configuration macros is exhaustive.
Definition: Module.h:252
QualType getTypeOfExprType(Expr *e) const
GCC extension.
Record code for the table of offsets to entries in the preprocessing record.
Definition: ASTBitCodes.h:484
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2620
ContinuousRangeMap< uint32_t, int, 2 > IdentifierRemap
Remapping table for identifier IDs in this module.
Definition: Module.h:267
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
QualType getParenType(QualType NamedType) const
CanQualType OMPArraySectionTy
Definition: ASTContext.h:1023
llvm::BitstreamCursor SLocEntryCursor
Cursor used to read source location entries.
Definition: Module.h:230
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
Defines version macros and version-related utility functions for Clang.
The OpenCL &#39;half&#39; / ARM NEON __fp16 type.
Definition: ASTBitCodes.h:882
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:551
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
Definition: DeclBase.h:721
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:245
ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a ...
Definition: ASTReader.h:320
Record code for #pragma diagnostic mappings.
Definition: ASTBitCodes.h:351
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:1494
DeclContext * getDeclContext()
Definition: DeclBase.h:425
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:209
unsigned LocalNumMacros
The number of macros in this AST file.
Definition: Module.h:290
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a source range.
Definition: ASTReader.cpp:8899
A record containing CXXCtorInitializers.
Definition: ASTBitCodes.h:1396
CanQualType ShortTy
Definition: ASTContext.h:1004
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:294
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2237
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
void setRParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:2298
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:329
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
Definition: Sanitizers.h:65
QualType getLocalType(ModuleFile &F, unsigned LocalID)
Resolve a local type ID within a given AST file into a type.
Definition: ASTReader.cpp:6873
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:100
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:837
Record code for the diagnostic options table.
Definition: ASTBitCodes.h:348
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:208
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:1006
An iterator that walks over all of the known identifiers in the lookup table.
SmallVector< uint64_t, 1 > ObjCCategories
The Objective-C category lists for categories known to this module.
Definition: Module.h:424
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1131
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1850
FileID OriginalSourceFileID
The file ID for the original source file that was used to build this AST file.
Definition: Module.h:138
A FunctionProtoType record.
Definition: ASTBitCodes.h:977
void setInheritConstructors(bool Inherit=true)
Set that this base class&#39;s constructors should be inherited.
Definition: DeclCXX.h:257
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:150
Describes a source location entry (SLocEntry) for a file.
Definition: ASTBitCodes.h:636
Wrapper for source info for enum types.
Definition: TypeLoc.h:725
A block containing a module file extension.
Definition: ASTBitCodes.h:272
bool isIdentifier() const
Predicate functions for querying what type of name this is.
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:117
std::string FileName
The file name of the module file.
Definition: Module.h:115
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:1002
void setEllipsisLoc(SourceLocation Loc)
Definition: TypeLoc.h:2242
Record code for an update to a decl context&#39;s lookup table.
Definition: ASTBitCodes.h:514
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:438
Record code for #pragma ms_struct options.
Definition: ASTBitCodes.h:608
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:452
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:1333
struct CXXOpName CXXOperatorName
void ReadPendingInstantiations(SmallVectorImpl< std::pair< ValueDecl *, SourceLocation >> &Pending) override
Definition: ASTReader.cpp:8105
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.
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:368
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:3681
Selector getSelector() const
Definition: DeclObjC.h:359
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:1347
The result type of a method or function.
void setLParenLoc(SourceLocation Loc)
Definition: TypeLoc.h:1938
unsigned SLocEntryBaseOffset
The base offset in the source manager&#39;s view of this module.
Definition: Module.h:239
Record code for the table of offsets of each identifier ID.
Definition: ASTBitCodes.h:404
void setQualifierLoc(NestedNameSpecifierLoc QualifierLoc)
Definition: TypeLoc.h:2073
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:719
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:591
void ReadDeclarationNameInfo(ModuleFile &F, DeclarationNameInfo &NameInfo, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8518
A DependentNameType record.
Definition: ASTBitCodes.h:1025
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true)
Lookup a module Search for a module with the given name.
const SourceManager & SM
Definition: Format.cpp:1337
unsigned MajorVersion
The major version of the extension data.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
CanQualType SignedCharTy
Definition: ASTContext.h:1004
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
Record code for the identifier table.
Definition: ASTBitCodes.h:423
The AST file was missing.
Definition: ASTReader.h:393
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:8780
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:873
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:3743
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:201
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:1842
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
Definition: Sanitizers.h:83
The Objective-C &#39;Class&#39; type.
Definition: ASTBitCodes.h:1130
SpecifierKind
The kind of specifier that completes this nested name specifier.
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:408
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:747
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:3680
StringRef Next() override
Retrieve the next string in the identifier table and advances the iterator for the following string...
Definition: ASTReader.cpp:7773
The &#39;unsigned long long&#39; type.
Definition: ASTBitCodes.h:807
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
Record code for the set of source location entries that need to be preloaded by the AST reader...
Definition: ASTBitCodes.h:474
QualifierInfo - A struct with extended info about a syntactic name qualifier, to be used for the case...
Definition: Decl.h:652
CanQualType OverloadTy
Definition: ASTContext.h:1013
The control block was read successfully.
Definition: ASTReader.h:387
The list of delegating constructor declarations.
Definition: ASTBitCodes.h:540
Information about a FileID, basically just the logical file that it represents and include stack info...
Compare comments&#39; source locations.
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:618
void setAttrOperandParensRange(SourceRange range)
Definition: TypeLoc.h:936
static bool readBit(unsigned &Bits)
Definition: ASTReader.cpp:902
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:373
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:144
#define false
Definition: stdbool.h:33
serialization::TypeID BaseTypeIndex
Base type ID for types local to this module as represented in the global type ID space.
Definition: Module.h:437
CanQualType BuiltinFnTy
Definition: ASTContext.h:1014
ContinuousRangeMap< uint32_t, int, 2 > SelectorRemap
Remapping table for selector IDs in this module.
Definition: Module.h:368
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:453
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3365
void LoadSelector(Selector Sel)
Load a selector from disk, registering its ID if it exists.
Definition: ASTReader.cpp:8141
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:2169
serialization::IdentID BaseIdentifierID
Base identifier ID for identifiers local to this module.
Definition: Module.h:264
MacroInfo * ReadMacroRecord(ModuleFile &F, uint64_t Offset)
Reads the macro record located at the given offset.
Definition: ASTReader.cpp:1561
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:7965
File is a PCH file treated as the preamble.
Definition: Module.h:51
std::string getTimestampFilename() const
Definition: Module.h:123
ContinuousRangeMap< unsigned, int, 2 > SLocRemap
Definition: ASTUnit.cpp:2260
static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method)
Move the given method to the back of the global list of methods.
Definition: ASTReader.cpp:3652
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3394
void MakeSuper(ASTContext &Context, CXXRecordDecl *RD, SourceLocation SuperLoc, SourceLocation ColonColonLoc)
Turns this (empty) nested-name-specifier into &#39;__super&#39; nested-name-specifier.
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:1996
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:762
StringRef getName() const
Definition: FileManager.h:84
A record that stores the set of declarations that are visible from a given DeclContext.
Definition: ASTBitCodes.h:1288
File is a PCH file treated as such.
Definition: Module.h:50
CanQualType Int128Ty
Definition: ASTContext.h:1004
IdentifierInfo * get(StringRef Name) override
Retrieve the IdentifierInfo for the named identifier.
Definition: ASTReader.cpp:7701
void setLength(unsigned Len)
Definition: Token.h:133
Specifies a library or framework to link against.
Definition: ASTBitCodes.h:734
Record code for file ID of the file or buffer that was used to generate the AST file.
Definition: ASTBitCodes.h:301
Represents a C++ temporary.
Definition: ExprCXX.h:1164
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5384
void InitializeContext()
Initializes the ASTContext.
Definition: ASTReader.cpp:4419
Specifies a header that falls into this (sub)module.
Definition: ASTBitCodes.h:710
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:351
void setUsed(bool Used=true)
Definition: Weak.h:36
typename Representation::const_iterator const_iterator
A ComplexType record.
Definition: ASTBitCodes.h:941
Record code for special CUDA declarations.
Definition: ASTBitCodes.h:528
Options for controlling the compiler diagnostics engine.
A list of "interesting" identifiers.
Definition: ASTBitCodes.h:587
NameVisibilityKind NameVisibility
The visibility of names within this particular module.
Definition: Module.h:268
An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files...
Definition: ASTReader.cpp:7740
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:269
DeclarationName getName() const
getName - Returns the embedded declaration name.
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2944
PredefinedTypeIDs
Predefined type IDs.
Definition: ASTBitCodes.h:781
All of the names in this module are hidden.
Definition: Module.h:262
File is an implicitly-loaded module.
Definition: Module.h:48
void setProtocolRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1044
The &#39;unsigned char&#39; type.
Definition: ASTBitCodes.h:795
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:2604
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
Definition: Module.h:458
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class...
Metadata describing this particular extension.
Definition: ASTBitCodes.h:357
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, bool Complain, std::string &SuggestedPredefines) override
Receives the preprocessor options.
Definition: ASTReader.cpp:200
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:8257
uint64_t SizeInBits
The size of this file, in bits.
Definition: Module.h:171
TemplateParameterList * ReadTemplateParameterList(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a template parameter list.
Definition: ASTReader.cpp:8656
An ObjCTypeParamType record.
Definition: ASTBitCodes.h:1064
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:825
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
ModuleReverseIterator rbegin()
Reverse iterator to traverse all loaded modules.
Record code for the offsets of each decl.
Definition: ASTBitCodes.h:396
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:7923
void * SelectorLookupTable
A pointer to an on-disk hash table of opaque type ASTSelectorLookupTable.
Definition: Module.h:380
Metadata for submodules as a whole.
Definition: ASTBitCodes.h:699
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:261
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...
A TypeOfExprType record.
Definition: ASTBitCodes.h:983
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:594
CanQualType FloatTy
Definition: ASTContext.h:1007
const FileEntry * Entry
Definition: Module.h:153
The (signed) &#39;short&#39; type.
Definition: ASTBitCodes.h:819
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:2190
void setDefinitionEndLoc(SourceLocation EndLoc)
Set the location of the last token in the macro.
Definition: MacroInfo.h:127
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:137
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
unsigned LocalNumDecls
The number of declarations in this AST file.
Definition: Module.h:390
void setUpgradedFromWarning(bool Value)
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:1889
The internal &#39;instancetype&#39; typedef.
Definition: ASTBitCodes.h:1142
CanQualType VoidTy
Definition: ASTContext.h:996
OptionsRecordTypes
Record types that occur within the options block inside the control block.
Definition: ASTBitCodes.h:320
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:89
CanQualType Float16Ty
Definition: ASTContext.h:1009
Describes the categories of an Objective-C class.
Definition: ASTBitCodes.h:1924
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:7075
The AST block, which acts as a container around the full AST block.
Definition: ASTBitCodes.h:230
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition: Type.h:1302
ArrayRef< ObjCMethodDecl * > getFactoryMethods() const
Retrieve the instance methods found by this visitor.
Definition: ASTReader.cpp:7898
IdentID ReadIdentifierID(const unsigned char *d)
Definition: ASTReader.cpp:908
A DeducedTemplateSpecializationType record.
Definition: ASTBitCodes.h:1067
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2121
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:694
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
void setAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1369
UnhashedControlBlockRecordTypes
Record codes for the unhashed control block.
Definition: ASTBitCodes.h:343
llvm::SetVector< ModuleFile * > ImportedBy
List of modules which depend on this module.
Definition: Module.h:448
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:43
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:266
Updates[]
Definition: OpenMPClause.h:140
An InjectedClassNameType record.
Definition: ASTBitCodes.h:1013
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:8171
const serialization::DeclID * FileSortedDecls
Array of file-level DeclIDs sorted by file.
Definition: Module.h:412
Record code for the extra statistics we gather while generating an AST file.
Definition: ASTBitCodes.h:446
static Decl * getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID)
Definition: ASTReader.cpp:7112
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1909
virtual void visitImport(StringRef Filename)
If needsImportVisitation returns true, this is called for each AST file imported by this AST file...
Definition: ASTReader.h:238
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3669
static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags, DiagnosticsEngine &Diags, bool Complain)
Definition: ASTReader.cpp:455
std::vector< InputFile > InputFilesLoaded
The input files that have been loaded from this AST file.
Definition: Module.h:215
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:8441
The &#39;signed char&#39; type.
Definition: ASTBitCodes.h:813
unsigned LocalNumSubmodules
The number of submodules in this module.
Definition: Module.h:345
unsigned ComputeHash(Selector Sel)
Definition: ASTCommon.cpp:167
The AST file was writtten with a different language/target configuration.
Definition: ASTReader.h:404
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:8425
const char * HeaderFileInfoTableData
Actual data for the on-disk hash table of header file information.
Definition: Module.h:337
void markIdentifierUpToDate(IdentifierInfo *II)
Note that this identifier is up-to-date.
Definition: ASTReader.cpp:1935
const llvm::support::unaligned_uint64_t * InputFileOffsets
Offsets for all of the input file entries in the AST file.
Definition: Module.h:212
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:586
Record code for the signature that identifiers this AST file.
Definition: ASTBitCodes.h:345
void addHeader(Module *Mod, Module::Header Header, ModuleHeaderRole Role, bool Imported=false)
Adds this header to the given module.
Definition: ModuleMap.cpp:1080
File is a PCH file treated as the actual main file.
Definition: Module.h:52
llvm::APFloat ReadAPFloat(const RecordData &Record, const llvm::fltSemantics &Sem, unsigned &Idx)
Read a floating-point value.
Definition: ASTReader.cpp:8922
Record code for referenced selector pool.
Definition: ASTBitCodes.h:492
The input file that has been loaded from this AST file, along with bools indicating whether this was ...
Definition: Module.h:59
void AddSubDecl(const Decl *D)
Definition: ODRHash.cpp:419
std::vector< std::string > MacroIncludes
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2368
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4633
ModuleFile * getLocalModuleFile(ModuleFile &M, unsigned ID)
Retrieve the module file with a given local ID within the specified ModuleFile.
Definition: ASTReader.cpp:8331
Record code for the set of non-builtin, special types.
Definition: ASTBitCodes.h:442
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:650
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1629
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:225
CanQualType UnsignedShortTy
Definition: ASTContext.h:1005
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:297
The ObjC &#39;id&#39; type.
Definition: ASTBitCodes.h:861
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:2802
unsigned LocalNumSelectors
The number of selectors new to this file.
Definition: Module.h:358
unsigned getObjCOrBuiltinID() const
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
CanQualType CharTy
Definition: ASTContext.h:998
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:289
Selector getLocalSelector(ModuleFile &M, unsigned LocalID)
Retrieve a selector from the given module with its local ID number.
Definition: ASTReader.cpp:8386
Describes a macro definition within the preprocessing record.
Definition: ASTBitCodes.h:689
const ASTTemplateArgumentListInfo * ReadASTTemplateArgumentListInfo(ModuleFile &F, const RecordData &Record, unsigned &Index)
Definition: ASTReader.cpp:6946
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
A conflict between two modules.
Definition: Module.h:349
void setClassTInfo(TypeSourceInfo *TI)
Definition: TypeLoc.h:1321
bool ReadSLocEntry(int ID) override
Read the source location entry with index ID.
Definition: ASTReader.cpp:1351
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain) override
Receives the header search options.
Definition: ASTReader.cpp:779
The internal &#39;__NSConstantString&#39; typedef.
Definition: ASTBitCodes.h:1160
Record code for the module name.
Definition: ASTBitCodes.h:308
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:940
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1016
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:2214
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:749
uint64_t SanitizerMask
Definition: Sanitizers.h:24
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:796
Describes an inclusion directive within the preprocessing record.
Definition: ASTBitCodes.h:693
The internal &#39;__builtin_ms_va_list&#39; typedef.
Definition: ASTBitCodes.h:1151
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block.
Definition: Module.h:387
unsigned IsMissingRequirement
Whether this module is missing a feature from Requirements.
Definition: Module.h:201
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:1256
Record code for a file sorted array of DeclIDs in a module.
Definition: ASTBitCodes.h:561
void setAmpAmpLoc(SourceLocation Loc)
Definition: TypeLoc.h:1383
CanQualType NullPtrTy
Definition: ASTContext.h:1012
Record code for the array of Objective-C categories (including extensions).
Definition: ASTBitCodes.h:575
void updateOutOfDateIdentifier(IdentifierInfo &II) override
Update an out-of-date identifier.
Definition: ASTReader.cpp:1910
void reserve(ASTContext &C, unsigned N)
Specifies a configuration macro for this module.
Definition: ASTBitCodes.h:737
void ReadDefinedMacros() override
Read the set of macros defined by this external macro source.
Definition: ASTReader.cpp:1806
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:684
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:4080
bool ReadFileSystemOptions(const FileSystemOptions &FSOpts, bool Complain) override
Receives the file system options.
Definition: ASTReader.cpp:185
The basic abstraction for the target Objective-C runtime.
Definition: ObjCRuntime.h:25
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:306
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:2163
Record code for the array of unused file scoped decls.
Definition: ASTBitCodes.h:480
A FunctionNoProtoType record.
Definition: ASTBitCodes.h:974
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:147
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:3807
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:358
File is an explicitly-loaded module.
Definition: Module.h:49
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2711
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
Definition: ASTReader.cpp:429
QualType getUnderlyingType() const
Definition: Decl.h:2853
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1006
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:230
const Expr * getInit() const
Definition: Decl.h:1212
AccessSpecifier getAccess() const
Definition: DeclBase.h:460
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.
void ReadExtVectorDecls(SmallVectorImpl< TypedefNameDecl *> &Decls) override
Read the set of ext_vector type declarations known to the external Sema source.
Definition: ASTReader.cpp:8033
DeclarationName - The name of a declaration.
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:576
Record code for the Objective-C method pool,.
Definition: ASTBitCodes.h:458
llvm::PointerIntPair< Module *, 1, bool > ExportDecl
Describes an exported module.
Definition: Module.h:281
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:142
Kind getKind() const
Definition: DeclBase.h:419
Specifies a header that is private to this submodule.
Definition: ASTBitCodes.h:743
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:214
U cast(CodeGen::Address addr)
Definition: Address.h:109
Describes a macro expansion within the preprocessing record.
Definition: ASTBitCodes.h:686
An EnumType record.
Definition: ASTBitCodes.h:992
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:3787
IdentifierTable & getIdentifierTable()
Retrieve the identifier table associated with the preprocessor.
Definition: ASTReader.cpp:8972
IdentifierResolver IdResolver
Definition: Sema.h:800
A map from continuous integer ranges to some value, with a very specialized interface.
Class that performs lookup for an identifier stored in an AST file.
void setExternalSLocEntrySource(ExternalSLocEntrySource *Source)
ContinuousRangeMap< uint32_t, int, 2 > MacroRemap
Remapping table for macro IDs in this module.
Definition: Module.h:303
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
An RValueReferenceType record.
Definition: ASTBitCodes.h:953
void ReadDeclarationNameLoc(ModuleFile &F, DeclarationNameLoc &DNLoc, DeclarationName Name, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8485
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
void ClearSwitchCaseIDs()
Definition: ASTReader.cpp:8990
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:766
void setHasExternalLexicalStorage(bool ES=true)
State whether this DeclContext has external storage for declarations lexically in this context...
Definition: DeclBase.h:1893
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:8117
An AtomicType record.
Definition: ASTBitCodes.h:1052
static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, ASTConsumer *Consumer)
Under non-PCH compilation the consumer receives the objc methods before receiving the implementation...
Definition: ASTReader.cpp:7439
The placeholder type for dependent types.
Definition: ASTBitCodes.h:843
All of the names in this module are visible.
Definition: Module.h:264
unsigned getNumParams() const
Definition: TypeLoc.h:1471
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:2084
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:615
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:6958
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:877
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:3379
void ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set, const RecordData &Record, unsigned &Idx)
Read a UnresolvedSet structure.
Definition: ASTReader.cpp:8686
void setAttrEnumOperandLoc(SourceLocation loc)
Definition: TypeLoc.h:923
struct CXXLitOpName CXXLiteralOperatorName
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:129
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
BuiltinTemplateDecl * getTypePackElementDecl() const
CanQualType UnknownAnyTy
Definition: ASTContext.h:1013
std::vector< Conflict > Conflicts
The list of conflicts.
Definition: Module.h:358
NestedNameSpecifierLoc ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:8835
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:5583
Record code for the table of offsets into the Objective-C method pool.
Definition: ASTBitCodes.h:455
Defines the clang::FileSystemOptions interface.
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2172
A DependentSizedArrayType record.
Definition: ASTBitCodes.h:1031
CanQualType UnsignedLongTy
Definition: ASTContext.h:1005
Record code for the remapping information used to relate loaded modules to the various offsets and ID...
Definition: ASTBitCodes.h:550
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
Definition: TemplateBase.h:682
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:1957
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:246
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
Definition: DeclBase.h:706
Record code for declarations that Sema keeps references of.
Definition: ASTBitCodes.h:501
void ReadTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, ModuleFile &F, const RecordData &Record, unsigned &Idx, bool Canonicalize=false)
Read a template argument array.
Definition: ASTReader.cpp:8676
CanQualType DependentTy
Definition: ASTContext.h:1013
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1984
void * HeaderFileInfoTable
The on-disk hash table that contains information about each of the header files.
Definition: Module.h:341
CanQualType WCharTy
Definition: ASTContext.h:999
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:9065
bool hasBody() const override
Determine whether this method has a body.
Definition: DeclObjC.h:524
Offsets into the input-files block where input files reside.
Definition: ASTBitCodes.h:305
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain, bool AllowCompatibleDifferences) override
Receives the language options.
Definition: ASTReader.cpp:160
CanQualType ObjCBuiltinClassTy
Definition: ASTContext.h:1016
unsigned getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
Definition: DeclBase.h:698
static std::pair< unsigned, unsigned > ReadKeyDataLength(const unsigned char *&d)
Definition: ASTReader.cpp:807
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1663
PreprocessorRecordTypes
Record types used within a preprocessor block.
Definition: ASTBitCodes.h:658
static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags)
Definition: ASTReader.cpp:485
CanQualType BoundMemberTy
Definition: ASTContext.h:1013
The block containing the submodule structure.
Definition: ASTBitCodes.h:248
QualType getAutoDeductType() const
C++11 deduction pattern for &#39;auto&#39; type.
void setTypeArgsRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1014
Wrapper for source info for record types.
Definition: TypeLoc.h:717
std::string BaseDirectory
The base directory of the module.
Definition: Module.h:121
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1934
unsigned CalculateHash()
Definition: ODRHash.cpp:177
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:194
ContinuousRangeMap< uint32_t, int, 2 > TypeRemap
Remapping table for type IDs in this module.
Definition: Module.h:440
Selector DecodeSelector(serialization::SelectorID Idx)
Definition: ASTReader.cpp:8390
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:1641
serialization::PreprocessedEntityID BasePreprocessedEntityID
Base preprocessed entity ID for preprocessed entities local to this module.
Definition: Module.h:319
Represents a base class of a C++ class.
Definition: DeclCXX.h:191
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:8419
unsigned BufferOverridden
Indicates whether the buffer itself was provided to override the actual file contents.
const Expr * Replacement
Definition: AttributeList.h:59
void PrintStats() override
Print some statistics about AST usage.
Definition: ASTReader.cpp:7466
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)
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
Metadata for a module file extension.
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3368
Keeps track of options that affect how file operations are performed.
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:2174
A TypedefType record.
Definition: ASTBitCodes.h:980
static bool ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, unsigned BlockID)
ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the specified cursor.
Definition: ASTReader.cpp:1531
QualType GetType(serialization::TypeID ID)
Resolve a type ID into a type, potentially building a new type.
Definition: ASTReader.cpp:6703
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:1378
void setLoc(SourceLocation L)
setLoc - Sets the main location of the declaration name.
ExternCContextDecl * getExternCContextDecl() const
IdentifierInfo * DecodeIdentifierInfo(serialization::IdentifierID ID)
Definition: ASTReader.cpp:8203
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3371
NestedNameSpecifierLoc QualifierLoc
Definition: Decl.h:653
virtual bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath, bool Complain)
Receives the header search options.
Definition: ASTReader.h:185
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:2282
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:989
const IntrusiveRefCntPtr< DiagnosticIDs > & getDiagnosticIDs() const
Definition: Diagnostic.h:412
The C++ &#39;char16_t&#39; type.
Definition: ASTBitCodes.h:855
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:6933
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2542
unsigned InferSubmodules
Whether we should infer submodules for this module based on the headers.
Definition: Module.h:237
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:6897
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
Selector GetExternalSelector(serialization::SelectorID ID) override
Resolve a selector ID into a selector.
Definition: ASTReader.cpp:8415
static const ASTTemplateArgumentListInfo * Create(ASTContext &C, const TemplateArgumentListInfo &List)
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:7231
virtual bool needsSystemInputFileVisitation()
Returns true if this ASTReaderListener wants to receive the system input files of the AST file via vi...
Definition: ASTReader.h:219
void ReadUnusedFileScopedDecls(SmallVectorImpl< const DeclaratorDecl *> &Decls) override
Read the set of unused file-scope declarations known to the external Sema source. ...
Definition: ASTReader.cpp:8011
An TemplateTypeParmType record.
Definition: ASTBitCodes.h:1019
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:219
static CXXTemporary * Create(const ASTContext &C, const CXXDestructorDecl *Destructor)
Definition: ExprCXX.cpp:748
SmallVector< uint64_t, 8 > PragmaDiagMappings
Diagnostic IDs and their mappings that the user changed.
Definition: Module.h:445
Record code for the filesystem options table.
Definition: ASTBitCodes.h:333
static hash_value_type ComputeHash(const internal_key_type &a)
Definition: ASTReader.cpp:872
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
Definition: ASTReader.cpp:1548
const char * IdentifierTableData
Actual data for the on-disk hash table of identifiers.
Definition: Module.h:273
void setParam(unsigned i, ParmVarDecl *VD)
Definition: TypeLoc.h:1478
bool needsAnonymousDeclarationNumber(const NamedDecl *D)
Determine whether the given declaration needs an anonymous declaration number.
Definition: ASTCommon.cpp:329
CanQualType Char16Ty
Definition: ASTContext.h:1002
Level
The level of the diagnostic, after it has been through mapping.
Definition: Diagnostic.h:150
static DiagnosticMapping deserialize(unsigned Bits)
Deserialize a mapping.
void setOutOfDate(bool OOD)
Set whether the information for this identifier is out of date with respect to the external source...
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:394
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:157
Declaration of a class template.
Record code for the offsets of each type.
Definition: ASTBitCodes.h:384
A DependentAddressSpaceType record.
Definition: ASTBitCodes.h:1073
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:2789
The block containing the definitions of all of the types and decls used within the AST file...
Definition: ASTBitCodes.h:242
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:1148
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:141
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:265
bool ReadDiagnosticOptions(IntrusiveRefCntPtr< DiagnosticOptions > DiagOpts, bool Complain) override
Receives the diagnostic options.
Definition: ASTReader.cpp:554
ASTIdentifierIterator(const ASTReader &Reader, bool SkipModules=false)
Definition: ASTReader.cpp:7768
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:759
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
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:397
TypeLocReader(ModuleFile &F, ASTReader &Reader, const ASTReader::RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:6383
Defines the clang::VersionTuple class, which represents a version in the form major[.minor[.subminor]].
NameVisibilityKind
Describes the visibility of the various names within a particular module.
Definition: Module.h:260
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:1941
The (signed) &#39;int&#39; type.
Definition: ASTBitCodes.h:822
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:3509
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1645
std::pair< ObjCMethodList, ObjCMethodList > GlobalMethods
Definition: Sema.h:1113
data_type ReadData(const internal_key_type &k, const unsigned char *d, unsigned DataLen)
Definition: ASTReader.cpp:924
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
Specifies a required feature.
Definition: ASTBitCodes.h:727
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:7093
std::vector< std::string > ConfigMacros
The set of "configuration macros", which are macros that (intentionally) change how this module is bu...
Definition: Module.h:333
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
CanQualType IntTy
Definition: ASTContext.h:1004
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:400
Record for offsets of DECL_UPDATES records for declarations that were modified after being deserializ...
Definition: ASTBitCodes.h:518
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:492
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:4687
llvm::BitstreamCursor PreprocessorDetailCursor
The cursor to the start of the (optional) detailed preprocessing record block.
Definition: Module.h:312
The C++ &#39;wchar_t&#39; type.
Definition: ASTBitCodes.h:816
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2077
The ObjC &#39;Class&#39; type.
Definition: ASTBitCodes.h:864
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:1121
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:7085
unsigned IsValid
Whether this file has been looked up as a header.
Definition: HeaderSearch.h:88
Record code for weak undeclared identifiers.
Definition: ASTBitCodes.h:504
The block containing information about the preprocessor.
Definition: ASTBitCodes.h:238
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:745
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:7456
void setLocation(SourceLocation L)
Definition: Token.h:132
bool getWarningsAsErrors() const
Definition: Diagnostic.h:525
QualType getType() const
Definition: Decl.h:638
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:336
Module * Other
The module that this module conflicts with.
Definition: Module.h:351
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
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
Definition: ASTContext.h:1712
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
Definition: ASTContext.h:1690
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:285
The block of input files, which were used as inputs to create this AST file.
Definition: ASTBitCodes.h:262
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:287
const uint32_t * SelectorOffsets
Offsets into the selector lookup table&#39;s data array where each selector resides.
Definition: Module.h:362
CanQualType BoolTy
Definition: ASTContext.h:997
void UpdateSema()
Update the state of Sema after loading some additional modules.
Definition: ASTReader.cpp:7639
unsigned LocalNumTypes
The number of types in this AST file.
Definition: Module.h:429
Represents a C++ namespace alias.
Definition: DeclCXX.h:2947
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1669
Kind
The basic Objective-C runtimes that we know about.
Definition: ObjCRuntime.h:28
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:1163
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:7214
InputFileRecordTypes
Record types that occur within the input-files block inside the control block.
Definition: ASTBitCodes.h:365
void FinishedDeserializing() override
Notify ASTReader that we finished the deserialization of a decl or type.
CanQualType DoubleTy
Definition: ASTContext.h:1007
A function-like macro definition.
Definition: ASTBitCodes.h:669
~ASTReader() override
The Objective-C &#39;Protocol&#39; type.
Definition: ASTBitCodes.h:1133
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:256
SourceLocation getLocStart() const LLVM_READONLY
Definition: Stmt.cpp:277
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:153
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
void setObjCOrBuiltinID(unsigned ID)
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1284
void ReadModuleName(StringRef ModuleName) override
Definition: ASTReader.cpp:149
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:3393
PredefinedDeclIDs
Predefined declaration IDs.
Definition: ASTBitCodes.h:1116
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
Record code for an update to the TU&#39;s lexically contained declarations.
Definition: ASTBitCodes.h:496
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3081
void setElaboratedKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:2005
Source range/offset of a preprocessed entity.
Definition: ASTBitCodes.h:202
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:224
SourceLocation getLocation() const
Definition: DeclBase.h:416
const serialization::ObjCCategoriesInfo * ObjCCategoriesMap
Array of category list location information within this module file, sorted by the definition ID...
Definition: Module.h:417
bool loadGlobalIndex()
Attempts to load the global index.
Definition: ASTReader.cpp:3765
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:8327
Objective-C "Class" redefinition type.
Definition: ASTBitCodes.h:1098
A PackExpansionType record.
Definition: ASTBitCodes.h:1037
void ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector< const TypedefNameDecl *, 4 > &Decls) override
Read the set of potentially unused typedefs known to the source.
Definition: ASTReader.cpp:8043
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:1021
The pseudo-object placeholder type.
Definition: ASTBitCodes.h:888
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:167
void setUnderlyingTInfo(TypeSourceInfo *TI) const
Definition: TypeLoc.h:1907
unsigned InferExplicitSubmodules
Whether, when inferring submodules, the inferred submodules should be explicit.
Definition: Module.h:241
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:611
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
Definition: ASTReader.cpp:8978
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
A DependentTemplateSpecializationType record.
Definition: ASTBitCodes.h:1028
CanQualType UnsignedIntTy
Definition: ASTContext.h:1005
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:8242
Record code for the array of tentative definitions.
Definition: ASTBitCodes.h:449
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
The &#39;__float128&#39; type.
Definition: ASTBitCodes.h:912
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
static NestedNameSpecifier * GlobalSpecifier(const ASTContext &Context)
Returns the nested name specifier representing the global scope.