1 //===- ASTReader.cpp - AST File Reader ------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the ASTReader class, which reads AST files.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/Basic/OpenMPKinds.h"
14 #include "clang/Serialization/ASTRecordReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/AbstractTypeReader.h"
18 #include "clang/AST/ASTConsumer.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/AST/ASTMutationListener.h"
21 #include "clang/AST/ASTUnresolvedSet.h"
22 #include "clang/AST/Decl.h"
23 #include "clang/AST/DeclBase.h"
24 #include "clang/AST/DeclCXX.h"
25 #include "clang/AST/DeclFriend.h"
26 #include "clang/AST/DeclGroup.h"
27 #include "clang/AST/DeclObjC.h"
28 #include "clang/AST/DeclTemplate.h"
29 #include "clang/AST/DeclarationName.h"
30 #include "clang/AST/Expr.h"
31 #include "clang/AST/ExprCXX.h"
32 #include "clang/AST/ExternalASTSource.h"
33 #include "clang/AST/NestedNameSpecifier.h"
34 #include "clang/AST/OpenMPClause.h"
35 #include "clang/AST/ODRHash.h"
36 #include "clang/AST/RawCommentList.h"
37 #include "clang/AST/TemplateBase.h"
38 #include "clang/AST/TemplateName.h"
39 #include "clang/AST/Type.h"
40 #include "clang/AST/TypeLoc.h"
41 #include "clang/AST/TypeLocVisitor.h"
42 #include "clang/AST/UnresolvedSet.h"
43 #include "clang/Basic/CommentOptions.h"
44 #include "clang/Basic/Diagnostic.h"
45 #include "clang/Basic/DiagnosticOptions.h"
46 #include "clang/Basic/ExceptionSpecificationType.h"
47 #include "clang/Basic/FileManager.h"
48 #include "clang/Basic/FileSystemOptions.h"
49 #include "clang/Basic/IdentifierTable.h"
50 #include "clang/Basic/LLVM.h"
51 #include "clang/Basic/LangOptions.h"
52 #include "clang/Basic/Module.h"
53 #include "clang/Basic/ObjCRuntime.h"
54 #include "clang/Basic/OperatorKinds.h"
55 #include "clang/Basic/PragmaKinds.h"
56 #include "clang/Basic/Sanitizers.h"
57 #include "clang/Basic/SourceLocation.h"
58 #include "clang/Basic/SourceManager.h"
59 #include "clang/Basic/SourceManagerInternals.h"
60 #include "clang/Basic/Specifiers.h"
61 #include "clang/Basic/TargetInfo.h"
62 #include "clang/Basic/TargetOptions.h"
63 #include "clang/Basic/TokenKinds.h"
64 #include "clang/Basic/Version.h"
65 #include "clang/Lex/HeaderSearch.h"
66 #include "clang/Lex/HeaderSearchOptions.h"
67 #include "clang/Lex/MacroInfo.h"
68 #include "clang/Lex/ModuleMap.h"
69 #include "clang/Lex/PreprocessingRecord.h"
70 #include "clang/Lex/Preprocessor.h"
71 #include "clang/Lex/PreprocessorOptions.h"
72 #include "clang/Lex/Token.h"
73 #include "clang/Sema/ObjCMethodList.h"
74 #include "clang/Sema/Scope.h"
75 #include "clang/Sema/Sema.h"
76 #include "clang/Sema/Weak.h"
77 #include "clang/Serialization/ASTBitCodes.h"
78 #include "clang/Serialization/ASTDeserializationListener.h"
79 #include "clang/Serialization/ContinuousRangeMap.h"
80 #include "clang/Serialization/GlobalModuleIndex.h"
81 #include "clang/Serialization/InMemoryModuleCache.h"
82 #include "clang/Serialization/ModuleFile.h"
83 #include "clang/Serialization/ModuleFileExtension.h"
84 #include "clang/Serialization/ModuleManager.h"
85 #include "clang/Serialization/PCHContainerOperations.h"
86 #include "clang/Serialization/SerializationDiagnostic.h"
87 #include "llvm/ADT/APFloat.h"
88 #include "llvm/ADT/APInt.h"
89 #include "llvm/ADT/APSInt.h"
90 #include "llvm/ADT/ArrayRef.h"
91 #include "llvm/ADT/DenseMap.h"
92 #include "llvm/ADT/FloatingPointMode.h"
93 #include "llvm/ADT/FoldingSet.h"
94 #include "llvm/ADT/Hashing.h"
95 #include "llvm/ADT/IntrusiveRefCntPtr.h"
96 #include "llvm/ADT/None.h"
97 #include "llvm/ADT/Optional.h"
98 #include "llvm/ADT/STLExtras.h"
99 #include "llvm/ADT/ScopeExit.h"
100 #include "llvm/ADT/SmallPtrSet.h"
101 #include "llvm/ADT/SmallString.h"
102 #include "llvm/ADT/SmallVector.h"
103 #include "llvm/ADT/StringExtras.h"
104 #include "llvm/ADT/StringMap.h"
105 #include "llvm/ADT/StringRef.h"
106 #include "llvm/ADT/Triple.h"
107 #include "llvm/ADT/iterator_range.h"
108 #include "llvm/Bitstream/BitstreamReader.h"
109 #include "llvm/Support/Casting.h"
110 #include "llvm/Support/Compiler.h"
111 #include "llvm/Support/Compression.h"
112 #include "llvm/Support/DJB.h"
113 #include "llvm/Support/Endian.h"
114 #include "llvm/Support/Error.h"
115 #include "llvm/Support/ErrorHandling.h"
116 #include "llvm/Support/FileSystem.h"
117 #include "llvm/Support/MemoryBuffer.h"
118 #include "llvm/Support/Path.h"
119 #include "llvm/Support/SaveAndRestore.h"
120 #include "llvm/Support/Timer.h"
121 #include "llvm/Support/VersionTuple.h"
122 #include "llvm/Support/raw_ostream.h"
123 #include <algorithm>
124 #include <cassert>
125 #include <cstddef>
126 #include <cstdint>
127 #include <cstdio>
128 #include <ctime>
129 #include <iterator>
130 #include <limits>
131 #include <map>
132 #include <memory>
133 #include <string>
134 #include <system_error>
135 #include <tuple>
136 #include <utility>
137 #include <vector>
138
139 using namespace clang;
140 using namespace clang::serialization;
141 using namespace clang::serialization::reader;
142 using llvm::BitstreamCursor;
143 using llvm::RoundingMode;
144
145 //===----------------------------------------------------------------------===//
146 // ChainedASTReaderListener implementation
147 //===----------------------------------------------------------------------===//
148
149 bool
ReadFullVersionInformation(StringRef FullVersion)150 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
151 return First->ReadFullVersionInformation(FullVersion) ||
152 Second->ReadFullVersionInformation(FullVersion);
153 }
154
ReadModuleName(StringRef ModuleName)155 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
156 First->ReadModuleName(ModuleName);
157 Second->ReadModuleName(ModuleName);
158 }
159
ReadModuleMapFile(StringRef ModuleMapPath)160 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
161 First->ReadModuleMapFile(ModuleMapPath);
162 Second->ReadModuleMapFile(ModuleMapPath);
163 }
164
165 bool
ReadLanguageOptions(const LangOptions & LangOpts,bool Complain,bool AllowCompatibleDifferences)166 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
167 bool Complain,
168 bool AllowCompatibleDifferences) {
169 return First->ReadLanguageOptions(LangOpts, Complain,
170 AllowCompatibleDifferences) ||
171 Second->ReadLanguageOptions(LangOpts, Complain,
172 AllowCompatibleDifferences);
173 }
174
ReadTargetOptions(const TargetOptions & TargetOpts,bool Complain,bool AllowCompatibleDifferences)175 bool ChainedASTReaderListener::ReadTargetOptions(
176 const TargetOptions &TargetOpts, bool Complain,
177 bool AllowCompatibleDifferences) {
178 return First->ReadTargetOptions(TargetOpts, Complain,
179 AllowCompatibleDifferences) ||
180 Second->ReadTargetOptions(TargetOpts, Complain,
181 AllowCompatibleDifferences);
182 }
183
ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,bool Complain)184 bool ChainedASTReaderListener::ReadDiagnosticOptions(
185 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
186 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
187 Second->ReadDiagnosticOptions(DiagOpts, Complain);
188 }
189
190 bool
ReadFileSystemOptions(const FileSystemOptions & FSOpts,bool Complain)191 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
192 bool Complain) {
193 return First->ReadFileSystemOptions(FSOpts, Complain) ||
194 Second->ReadFileSystemOptions(FSOpts, Complain);
195 }
196
ReadHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,bool Complain)197 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
198 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
199 bool Complain) {
200 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
201 Complain) ||
202 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
203 Complain);
204 }
205
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)206 bool ChainedASTReaderListener::ReadPreprocessorOptions(
207 const PreprocessorOptions &PPOpts, bool Complain,
208 std::string &SuggestedPredefines) {
209 return First->ReadPreprocessorOptions(PPOpts, Complain,
210 SuggestedPredefines) ||
211 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
212 }
213
ReadCounter(const serialization::ModuleFile & M,unsigned Value)214 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
215 unsigned Value) {
216 First->ReadCounter(M, Value);
217 Second->ReadCounter(M, Value);
218 }
219
needsInputFileVisitation()220 bool ChainedASTReaderListener::needsInputFileVisitation() {
221 return First->needsInputFileVisitation() ||
222 Second->needsInputFileVisitation();
223 }
224
needsSystemInputFileVisitation()225 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
226 return First->needsSystemInputFileVisitation() ||
227 Second->needsSystemInputFileVisitation();
228 }
229
visitModuleFile(StringRef Filename,ModuleKind Kind)230 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
231 ModuleKind Kind) {
232 First->visitModuleFile(Filename, Kind);
233 Second->visitModuleFile(Filename, Kind);
234 }
235
visitInputFile(StringRef Filename,bool isSystem,bool isOverridden,bool isExplicitModule)236 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
237 bool isSystem,
238 bool isOverridden,
239 bool isExplicitModule) {
240 bool Continue = false;
241 if (First->needsInputFileVisitation() &&
242 (!isSystem || First->needsSystemInputFileVisitation()))
243 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
244 isExplicitModule);
245 if (Second->needsInputFileVisitation() &&
246 (!isSystem || Second->needsSystemInputFileVisitation()))
247 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
248 isExplicitModule);
249 return Continue;
250 }
251
readModuleFileExtension(const ModuleFileExtensionMetadata & Metadata)252 void ChainedASTReaderListener::readModuleFileExtension(
253 const ModuleFileExtensionMetadata &Metadata) {
254 First->readModuleFileExtension(Metadata);
255 Second->readModuleFileExtension(Metadata);
256 }
257
258 //===----------------------------------------------------------------------===//
259 // PCH validator implementation
260 //===----------------------------------------------------------------------===//
261
262 ASTReaderListener::~ASTReaderListener() = default;
263
264 /// Compare the given set of language options against an existing set of
265 /// language options.
266 ///
267 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
268 /// \param AllowCompatibleDifferences If true, differences between compatible
269 /// language options will be permitted.
270 ///
271 /// \returns true if the languagae options mis-match, false otherwise.
checkLanguageOptions(const LangOptions & LangOpts,const LangOptions & ExistingLangOpts,DiagnosticsEngine * Diags,bool AllowCompatibleDifferences=true)272 static bool checkLanguageOptions(const LangOptions &LangOpts,
273 const LangOptions &ExistingLangOpts,
274 DiagnosticsEngine *Diags,
275 bool AllowCompatibleDifferences = true) {
276 #define LANGOPT(Name, Bits, Default, Description) \
277 if (ExistingLangOpts.Name != LangOpts.Name) { \
278 if (Diags) \
279 Diags->Report(diag::err_pch_langopt_mismatch) \
280 << Description << LangOpts.Name << ExistingLangOpts.Name; \
281 return true; \
282 }
283
284 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
285 if (ExistingLangOpts.Name != LangOpts.Name) { \
286 if (Diags) \
287 Diags->Report(diag::err_pch_langopt_value_mismatch) \
288 << Description; \
289 return true; \
290 }
291
292 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
293 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
294 if (Diags) \
295 Diags->Report(diag::err_pch_langopt_value_mismatch) \
296 << Description; \
297 return true; \
298 }
299
300 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
301 if (!AllowCompatibleDifferences) \
302 LANGOPT(Name, Bits, Default, Description)
303
304 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
305 if (!AllowCompatibleDifferences) \
306 ENUM_LANGOPT(Name, Bits, Default, Description)
307
308 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
309 if (!AllowCompatibleDifferences) \
310 VALUE_LANGOPT(Name, Bits, Default, Description)
311
312 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
313 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
314 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
315 #include "clang/Basic/LangOptions.def"
316
317 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
318 if (Diags)
319 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
320 return true;
321 }
322
323 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
324 if (Diags)
325 Diags->Report(diag::err_pch_langopt_value_mismatch)
326 << "target Objective-C runtime";
327 return true;
328 }
329
330 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
331 LangOpts.CommentOpts.BlockCommandNames) {
332 if (Diags)
333 Diags->Report(diag::err_pch_langopt_value_mismatch)
334 << "block command names";
335 return true;
336 }
337
338 // Sanitizer feature mismatches are treated as compatible differences. If
339 // compatible differences aren't allowed, we still only want to check for
340 // mismatches of non-modular sanitizers (the only ones which can affect AST
341 // generation).
342 if (!AllowCompatibleDifferences) {
343 SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
344 SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
345 SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
346 ExistingSanitizers.clear(ModularSanitizers);
347 ImportedSanitizers.clear(ModularSanitizers);
348 if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
349 const std::string Flag = "-fsanitize=";
350 if (Diags) {
351 #define SANITIZER(NAME, ID) \
352 { \
353 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
354 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
355 if (InExistingModule != InImportedModule) \
356 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
357 << InExistingModule << (Flag + NAME); \
358 }
359 #include "clang/Basic/Sanitizers.def"
360 }
361 return true;
362 }
363 }
364
365 return false;
366 }
367
368 /// Compare the given set of target options against an existing set of
369 /// target options.
370 ///
371 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
372 ///
373 /// \returns true if the target options mis-match, false otherwise.
checkTargetOptions(const TargetOptions & TargetOpts,const TargetOptions & ExistingTargetOpts,DiagnosticsEngine * Diags,bool AllowCompatibleDifferences=true)374 static bool checkTargetOptions(const TargetOptions &TargetOpts,
375 const TargetOptions &ExistingTargetOpts,
376 DiagnosticsEngine *Diags,
377 bool AllowCompatibleDifferences = true) {
378 #define CHECK_TARGET_OPT(Field, Name) \
379 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
380 if (Diags) \
381 Diags->Report(diag::err_pch_targetopt_mismatch) \
382 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
383 return true; \
384 }
385
386 // The triple and ABI must match exactly.
387 CHECK_TARGET_OPT(Triple, "target");
388 CHECK_TARGET_OPT(ABI, "target ABI");
389
390 // We can tolerate different CPUs in many cases, notably when one CPU
391 // supports a strict superset of another. When allowing compatible
392 // differences skip this check.
393 if (!AllowCompatibleDifferences)
394 CHECK_TARGET_OPT(CPU, "target CPU");
395
396 #undef CHECK_TARGET_OPT
397
398 // Compare feature sets.
399 SmallVector<StringRef, 4> ExistingFeatures(
400 ExistingTargetOpts.FeaturesAsWritten.begin(),
401 ExistingTargetOpts.FeaturesAsWritten.end());
402 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
403 TargetOpts.FeaturesAsWritten.end());
404 llvm::sort(ExistingFeatures);
405 llvm::sort(ReadFeatures);
406
407 // We compute the set difference in both directions explicitly so that we can
408 // diagnose the differences differently.
409 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
410 std::set_difference(
411 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
412 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
413 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
414 ExistingFeatures.begin(), ExistingFeatures.end(),
415 std::back_inserter(UnmatchedReadFeatures));
416
417 // If we are allowing compatible differences and the read feature set is
418 // a strict subset of the existing feature set, there is nothing to diagnose.
419 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
420 return false;
421
422 if (Diags) {
423 for (StringRef Feature : UnmatchedReadFeatures)
424 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
425 << /* is-existing-feature */ false << Feature;
426 for (StringRef Feature : UnmatchedExistingFeatures)
427 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
428 << /* is-existing-feature */ true << Feature;
429 }
430
431 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
432 }
433
434 bool
ReadLanguageOptions(const LangOptions & LangOpts,bool Complain,bool AllowCompatibleDifferences)435 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
436 bool Complain,
437 bool AllowCompatibleDifferences) {
438 const LangOptions &ExistingLangOpts = PP.getLangOpts();
439 return checkLanguageOptions(LangOpts, ExistingLangOpts,
440 Complain ? &Reader.Diags : nullptr,
441 AllowCompatibleDifferences);
442 }
443
ReadTargetOptions(const TargetOptions & TargetOpts,bool Complain,bool AllowCompatibleDifferences)444 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
445 bool Complain,
446 bool AllowCompatibleDifferences) {
447 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
448 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
449 Complain ? &Reader.Diags : nullptr,
450 AllowCompatibleDifferences);
451 }
452
453 namespace {
454
455 using MacroDefinitionsMap =
456 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
457 using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
458
459 } // namespace
460
checkDiagnosticGroupMappings(DiagnosticsEngine & StoredDiags,DiagnosticsEngine & Diags,bool Complain)461 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
462 DiagnosticsEngine &Diags,
463 bool Complain) {
464 using Level = DiagnosticsEngine::Level;
465
466 // Check current mappings for new -Werror mappings, and the stored mappings
467 // for cases that were explicitly mapped to *not* be errors that are now
468 // errors because of options like -Werror.
469 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
470
471 for (DiagnosticsEngine *MappingSource : MappingSources) {
472 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
473 diag::kind DiagID = DiagIDMappingPair.first;
474 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
475 if (CurLevel < DiagnosticsEngine::Error)
476 continue; // not significant
477 Level StoredLevel =
478 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
479 if (StoredLevel < DiagnosticsEngine::Error) {
480 if (Complain)
481 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
482 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
483 return true;
484 }
485 }
486 }
487
488 return false;
489 }
490
isExtHandlingFromDiagsError(DiagnosticsEngine & Diags)491 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
492 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
493 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
494 return true;
495 return Ext >= diag::Severity::Error;
496 }
497
checkDiagnosticMappings(DiagnosticsEngine & StoredDiags,DiagnosticsEngine & Diags,bool IsSystem,bool Complain)498 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
499 DiagnosticsEngine &Diags,
500 bool IsSystem, bool Complain) {
501 // Top-level options
502 if (IsSystem) {
503 if (Diags.getSuppressSystemWarnings())
504 return false;
505 // If -Wsystem-headers was not enabled before, be conservative
506 if (StoredDiags.getSuppressSystemWarnings()) {
507 if (Complain)
508 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
509 return true;
510 }
511 }
512
513 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
514 if (Complain)
515 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
516 return true;
517 }
518
519 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
520 !StoredDiags.getEnableAllWarnings()) {
521 if (Complain)
522 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
523 return true;
524 }
525
526 if (isExtHandlingFromDiagsError(Diags) &&
527 !isExtHandlingFromDiagsError(StoredDiags)) {
528 if (Complain)
529 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
530 return true;
531 }
532
533 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
534 }
535
536 /// Return the top import module if it is implicit, nullptr otherwise.
getTopImportImplicitModule(ModuleManager & ModuleMgr,Preprocessor & PP)537 static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
538 Preprocessor &PP) {
539 // If the original import came from a file explicitly generated by the user,
540 // don't check the diagnostic mappings.
541 // FIXME: currently this is approximated by checking whether this is not a
542 // module import of an implicitly-loaded module file.
543 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
544 // the transitive closure of its imports, since unrelated modules cannot be
545 // imported until after this module finishes validation.
546 ModuleFile *TopImport = &*ModuleMgr.rbegin();
547 while (!TopImport->ImportedBy.empty())
548 TopImport = TopImport->ImportedBy[0];
549 if (TopImport->Kind != MK_ImplicitModule)
550 return nullptr;
551
552 StringRef ModuleName = TopImport->ModuleName;
553 assert(!ModuleName.empty() && "diagnostic options read before module name");
554
555 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
556 assert(M && "missing module");
557 return M;
558 }
559
ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,bool Complain)560 bool PCHValidator::ReadDiagnosticOptions(
561 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
562 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
563 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
564 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
565 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
566 // This should never fail, because we would have processed these options
567 // before writing them to an ASTFile.
568 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
569
570 ModuleManager &ModuleMgr = Reader.getModuleManager();
571 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
572
573 Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
574 if (!TopM)
575 return false;
576
577 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
578 // contains the union of their flags.
579 return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
580 Complain);
581 }
582
583 /// Collect the macro definitions provided by the given preprocessor
584 /// options.
585 static void
collectMacroDefinitions(const PreprocessorOptions & PPOpts,MacroDefinitionsMap & Macros,SmallVectorImpl<StringRef> * MacroNames=nullptr)586 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
587 MacroDefinitionsMap &Macros,
588 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
589 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
590 StringRef Macro = PPOpts.Macros[I].first;
591 bool IsUndef = PPOpts.Macros[I].second;
592
593 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
594 StringRef MacroName = MacroPair.first;
595 StringRef MacroBody = MacroPair.second;
596
597 // For an #undef'd macro, we only care about the name.
598 if (IsUndef) {
599 if (MacroNames && !Macros.count(MacroName))
600 MacroNames->push_back(MacroName);
601
602 Macros[MacroName] = std::make_pair("", true);
603 continue;
604 }
605
606 // For a #define'd macro, figure out the actual definition.
607 if (MacroName.size() == Macro.size())
608 MacroBody = "1";
609 else {
610 // Note: GCC drops anything following an end-of-line character.
611 StringRef::size_type End = MacroBody.find_first_of("\n\r");
612 MacroBody = MacroBody.substr(0, End);
613 }
614
615 if (MacroNames && !Macros.count(MacroName))
616 MacroNames->push_back(MacroName);
617 Macros[MacroName] = std::make_pair(MacroBody, false);
618 }
619 }
620
621 /// Check the preprocessor options deserialized from the control block
622 /// against the preprocessor options in an existing preprocessor.
623 ///
624 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
625 /// \param Validate If true, validate preprocessor options. If false, allow
626 /// macros defined by \p ExistingPPOpts to override those defined by
627 /// \p PPOpts in SuggestedPredefines.
checkPreprocessorOptions(const PreprocessorOptions & PPOpts,const PreprocessorOptions & ExistingPPOpts,DiagnosticsEngine * Diags,FileManager & FileMgr,std::string & SuggestedPredefines,const LangOptions & LangOpts,bool Validate=true)628 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
629 const PreprocessorOptions &ExistingPPOpts,
630 DiagnosticsEngine *Diags,
631 FileManager &FileMgr,
632 std::string &SuggestedPredefines,
633 const LangOptions &LangOpts,
634 bool Validate = true) {
635 // Check macro definitions.
636 MacroDefinitionsMap ASTFileMacros;
637 collectMacroDefinitions(PPOpts, ASTFileMacros);
638 MacroDefinitionsMap ExistingMacros;
639 SmallVector<StringRef, 4> ExistingMacroNames;
640 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
641
642 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
643 // Dig out the macro definition in the existing preprocessor options.
644 StringRef MacroName = ExistingMacroNames[I];
645 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
646
647 // Check whether we know anything about this macro name or not.
648 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
649 ASTFileMacros.find(MacroName);
650 if (!Validate || Known == ASTFileMacros.end()) {
651 // FIXME: Check whether this identifier was referenced anywhere in the
652 // AST file. If so, we should reject the AST file. Unfortunately, this
653 // information isn't in the control block. What shall we do about it?
654
655 if (Existing.second) {
656 SuggestedPredefines += "#undef ";
657 SuggestedPredefines += MacroName.str();
658 SuggestedPredefines += '\n';
659 } else {
660 SuggestedPredefines += "#define ";
661 SuggestedPredefines += MacroName.str();
662 SuggestedPredefines += ' ';
663 SuggestedPredefines += Existing.first.str();
664 SuggestedPredefines += '\n';
665 }
666 continue;
667 }
668
669 // If the macro was defined in one but undef'd in the other, we have a
670 // conflict.
671 if (Existing.second != Known->second.second) {
672 if (Diags) {
673 Diags->Report(diag::err_pch_macro_def_undef)
674 << MacroName << Known->second.second;
675 }
676 return true;
677 }
678
679 // If the macro was #undef'd in both, or if the macro bodies are identical,
680 // it's fine.
681 if (Existing.second || Existing.first == Known->second.first)
682 continue;
683
684 // The macro bodies differ; complain.
685 if (Diags) {
686 Diags->Report(diag::err_pch_macro_def_conflict)
687 << MacroName << Known->second.first << Existing.first;
688 }
689 return true;
690 }
691
692 // Check whether we're using predefines.
693 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
694 if (Diags) {
695 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
696 }
697 return true;
698 }
699
700 // Detailed record is important since it is used for the module cache hash.
701 if (LangOpts.Modules &&
702 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
703 if (Diags) {
704 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
705 }
706 return true;
707 }
708
709 // Compute the #include and #include_macros lines we need.
710 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
711 StringRef File = ExistingPPOpts.Includes[I];
712
713 if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
714 !ExistingPPOpts.PCHThroughHeader.empty()) {
715 // In case the through header is an include, we must add all the includes
716 // to the predefines so the start point can be determined.
717 SuggestedPredefines += "#include \"";
718 SuggestedPredefines += File;
719 SuggestedPredefines += "\"\n";
720 continue;
721 }
722
723 if (File == ExistingPPOpts.ImplicitPCHInclude)
724 continue;
725
726 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
727 != PPOpts.Includes.end())
728 continue;
729
730 SuggestedPredefines += "#include \"";
731 SuggestedPredefines += File;
732 SuggestedPredefines += "\"\n";
733 }
734
735 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
736 StringRef File = ExistingPPOpts.MacroIncludes[I];
737 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
738 File)
739 != PPOpts.MacroIncludes.end())
740 continue;
741
742 SuggestedPredefines += "#__include_macros \"";
743 SuggestedPredefines += File;
744 SuggestedPredefines += "\"\n##\n";
745 }
746
747 return false;
748 }
749
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)750 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
751 bool Complain,
752 std::string &SuggestedPredefines) {
753 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
754
755 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
756 Complain? &Reader.Diags : nullptr,
757 PP.getFileManager(),
758 SuggestedPredefines,
759 PP.getLangOpts());
760 }
761
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)762 bool SimpleASTReaderListener::ReadPreprocessorOptions(
763 const PreprocessorOptions &PPOpts,
764 bool Complain,
765 std::string &SuggestedPredefines) {
766 return checkPreprocessorOptions(PPOpts,
767 PP.getPreprocessorOpts(),
768 nullptr,
769 PP.getFileManager(),
770 SuggestedPredefines,
771 PP.getLangOpts(),
772 false);
773 }
774
775 /// Check the header search options deserialized from the control block
776 /// against the header search options in an existing preprocessor.
777 ///
778 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
checkHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,StringRef ExistingModuleCachePath,DiagnosticsEngine * Diags,const LangOptions & LangOpts)779 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
780 StringRef SpecificModuleCachePath,
781 StringRef ExistingModuleCachePath,
782 DiagnosticsEngine *Diags,
783 const LangOptions &LangOpts) {
784 if (LangOpts.Modules) {
785 if (SpecificModuleCachePath != ExistingModuleCachePath) {
786 if (Diags)
787 Diags->Report(diag::err_pch_modulecache_mismatch)
788 << SpecificModuleCachePath << ExistingModuleCachePath;
789 return true;
790 }
791 }
792
793 return false;
794 }
795
ReadHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,bool Complain)796 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
797 StringRef SpecificModuleCachePath,
798 bool Complain) {
799 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
800 PP.getHeaderSearchInfo().getModuleCachePath(),
801 Complain ? &Reader.Diags : nullptr,
802 PP.getLangOpts());
803 }
804
ReadCounter(const ModuleFile & M,unsigned Value)805 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
806 PP.setCounterValue(Value);
807 }
808
809 //===----------------------------------------------------------------------===//
810 // AST reader implementation
811 //===----------------------------------------------------------------------===//
812
setDeserializationListener(ASTDeserializationListener * Listener,bool TakeOwnership)813 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
814 bool TakeOwnership) {
815 DeserializationListener = Listener;
816 OwnsDeserializationListener = TakeOwnership;
817 }
818
ComputeHash(Selector Sel)819 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
820 return serialization::ComputeHash(Sel);
821 }
822
823 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)824 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
825 using namespace llvm::support;
826
827 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
828 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
829 return std::make_pair(KeyLen, DataLen);
830 }
831
832 ASTSelectorLookupTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)833 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
834 using namespace llvm::support;
835
836 SelectorTable &SelTable = Reader.getContext().Selectors;
837 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
838 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
839 F, endian::readNext<uint32_t, little, unaligned>(d));
840 if (N == 0)
841 return SelTable.getNullarySelector(FirstII);
842 else if (N == 1)
843 return SelTable.getUnarySelector(FirstII);
844
845 SmallVector<IdentifierInfo *, 16> Args;
846 Args.push_back(FirstII);
847 for (unsigned I = 1; I != N; ++I)
848 Args.push_back(Reader.getLocalIdentifier(
849 F, endian::readNext<uint32_t, little, unaligned>(d)));
850
851 return SelTable.getSelector(N, Args.data());
852 }
853
854 ASTSelectorLookupTrait::data_type
ReadData(Selector,const unsigned char * d,unsigned DataLen)855 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
856 unsigned DataLen) {
857 using namespace llvm::support;
858
859 data_type Result;
860
861 Result.ID = Reader.getGlobalSelectorID(
862 F, endian::readNext<uint32_t, little, unaligned>(d));
863 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
864 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
865 Result.InstanceBits = FullInstanceBits & 0x3;
866 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
867 Result.FactoryBits = FullFactoryBits & 0x3;
868 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
869 unsigned NumInstanceMethods = FullInstanceBits >> 3;
870 unsigned NumFactoryMethods = FullFactoryBits >> 3;
871
872 // Load instance methods
873 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
874 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
875 F, endian::readNext<uint32_t, little, unaligned>(d)))
876 Result.Instance.push_back(Method);
877 }
878
879 // Load factory methods
880 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
881 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
882 F, endian::readNext<uint32_t, little, unaligned>(d)))
883 Result.Factory.push_back(Method);
884 }
885
886 return Result;
887 }
888
ComputeHash(const internal_key_type & a)889 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
890 return llvm::djbHash(a);
891 }
892
893 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)894 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
895 using namespace llvm::support;
896
897 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
898 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
899 return std::make_pair(KeyLen, DataLen);
900 }
901
902 ASTIdentifierLookupTraitBase::internal_key_type
ReadKey(const unsigned char * d,unsigned n)903 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
904 assert(n >= 2 && d[n-1] == '\0');
905 return StringRef((const char*) d, n-1);
906 }
907
908 /// Whether the given identifier is "interesting".
isInterestingIdentifier(ASTReader & Reader,IdentifierInfo & II,bool IsModule)909 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
910 bool IsModule) {
911 return II.hadMacroDefinition() ||
912 II.isPoisoned() ||
913 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
914 II.hasRevertedTokenIDToIdentifier() ||
915 (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
916 II.getFETokenInfo());
917 }
918
readBit(unsigned & Bits)919 static bool readBit(unsigned &Bits) {
920 bool Value = Bits & 0x1;
921 Bits >>= 1;
922 return Value;
923 }
924
ReadIdentifierID(const unsigned char * d)925 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
926 using namespace llvm::support;
927
928 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
929 return Reader.getGlobalIdentifierID(F, RawID >> 1);
930 }
931
markIdentifierFromAST(ASTReader & Reader,IdentifierInfo & II)932 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
933 if (!II.isFromAST()) {
934 II.setIsFromAST();
935 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
936 if (isInterestingIdentifier(Reader, II, IsModule))
937 II.setChangedSinceDeserialization();
938 }
939 }
940
ReadData(const internal_key_type & k,const unsigned char * d,unsigned DataLen)941 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
942 const unsigned char* d,
943 unsigned DataLen) {
944 using namespace llvm::support;
945
946 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
947 bool IsInteresting = RawID & 0x01;
948
949 // Wipe out the "is interesting" bit.
950 RawID = RawID >> 1;
951
952 // Build the IdentifierInfo and link the identifier ID with it.
953 IdentifierInfo *II = KnownII;
954 if (!II) {
955 II = &Reader.getIdentifierTable().getOwn(k);
956 KnownII = II;
957 }
958 markIdentifierFromAST(Reader, *II);
959 Reader.markIdentifierUpToDate(II);
960
961 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
962 if (!IsInteresting) {
963 // For uninteresting identifiers, there's nothing else to do. Just notify
964 // the reader that we've finished loading this identifier.
965 Reader.SetIdentifierInfo(ID, II);
966 return II;
967 }
968
969 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
970 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
971 bool CPlusPlusOperatorKeyword = readBit(Bits);
972 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
973 bool HasRevertedBuiltin = readBit(Bits);
974 bool Poisoned = readBit(Bits);
975 bool ExtensionToken = readBit(Bits);
976 bool HadMacroDefinition = readBit(Bits);
977
978 assert(Bits == 0 && "Extra bits in the identifier?");
979 DataLen -= 8;
980
981 // Set or check the various bits in the IdentifierInfo structure.
982 // Token IDs are read-only.
983 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
984 II->revertTokenIDToIdentifier();
985 if (!F.isModule())
986 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
987 else if (HasRevertedBuiltin && II->getBuiltinID()) {
988 II->revertBuiltin();
989 assert((II->hasRevertedBuiltin() ||
990 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
991 "Incorrect ObjC keyword or builtin ID");
992 }
993 assert(II->isExtensionToken() == ExtensionToken &&
994 "Incorrect extension token flag");
995 (void)ExtensionToken;
996 if (Poisoned)
997 II->setIsPoisoned(true);
998 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
999 "Incorrect C++ operator keyword flag");
1000 (void)CPlusPlusOperatorKeyword;
1001
1002 // If this identifier is a macro, deserialize the macro
1003 // definition.
1004 if (HadMacroDefinition) {
1005 uint32_t MacroDirectivesOffset =
1006 endian::readNext<uint32_t, little, unaligned>(d);
1007 DataLen -= 4;
1008
1009 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1010 }
1011
1012 Reader.SetIdentifierInfo(ID, II);
1013
1014 // Read all of the declarations visible at global scope with this
1015 // name.
1016 if (DataLen > 0) {
1017 SmallVector<uint32_t, 4> DeclIDs;
1018 for (; DataLen > 0; DataLen -= 4)
1019 DeclIDs.push_back(Reader.getGlobalDeclID(
1020 F, endian::readNext<uint32_t, little, unaligned>(d)));
1021 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1022 }
1023
1024 return II;
1025 }
1026
DeclarationNameKey(DeclarationName Name)1027 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1028 : Kind(Name.getNameKind()) {
1029 switch (Kind) {
1030 case DeclarationName::Identifier:
1031 Data = (uint64_t)Name.getAsIdentifierInfo();
1032 break;
1033 case DeclarationName::ObjCZeroArgSelector:
1034 case DeclarationName::ObjCOneArgSelector:
1035 case DeclarationName::ObjCMultiArgSelector:
1036 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1037 break;
1038 case DeclarationName::CXXOperatorName:
1039 Data = Name.getCXXOverloadedOperator();
1040 break;
1041 case DeclarationName::CXXLiteralOperatorName:
1042 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1043 break;
1044 case DeclarationName::CXXDeductionGuideName:
1045 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1046 ->getDeclName().getAsIdentifierInfo();
1047 break;
1048 case DeclarationName::CXXConstructorName:
1049 case DeclarationName::CXXDestructorName:
1050 case DeclarationName::CXXConversionFunctionName:
1051 case DeclarationName::CXXUsingDirective:
1052 Data = 0;
1053 break;
1054 }
1055 }
1056
getHash() const1057 unsigned DeclarationNameKey::getHash() const {
1058 llvm::FoldingSetNodeID ID;
1059 ID.AddInteger(Kind);
1060
1061 switch (Kind) {
1062 case DeclarationName::Identifier:
1063 case DeclarationName::CXXLiteralOperatorName:
1064 case DeclarationName::CXXDeductionGuideName:
1065 ID.AddString(((IdentifierInfo*)Data)->getName());
1066 break;
1067 case DeclarationName::ObjCZeroArgSelector:
1068 case DeclarationName::ObjCOneArgSelector:
1069 case DeclarationName::ObjCMultiArgSelector:
1070 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1071 break;
1072 case DeclarationName::CXXOperatorName:
1073 ID.AddInteger((OverloadedOperatorKind)Data);
1074 break;
1075 case DeclarationName::CXXConstructorName:
1076 case DeclarationName::CXXDestructorName:
1077 case DeclarationName::CXXConversionFunctionName:
1078 case DeclarationName::CXXUsingDirective:
1079 break;
1080 }
1081
1082 return ID.ComputeHash();
1083 }
1084
1085 ModuleFile *
ReadFileRef(const unsigned char * & d)1086 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1087 using namespace llvm::support;
1088
1089 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1090 return Reader.getLocalModuleFile(F, ModuleFileID);
1091 }
1092
1093 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)1094 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1095 using namespace llvm::support;
1096
1097 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1098 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1099 return std::make_pair(KeyLen, DataLen);
1100 }
1101
1102 ASTDeclContextNameLookupTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)1103 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1104 using namespace llvm::support;
1105
1106 auto Kind = (DeclarationName::NameKind)*d++;
1107 uint64_t Data;
1108 switch (Kind) {
1109 case DeclarationName::Identifier:
1110 case DeclarationName::CXXLiteralOperatorName:
1111 case DeclarationName::CXXDeductionGuideName:
1112 Data = (uint64_t)Reader.getLocalIdentifier(
1113 F, endian::readNext<uint32_t, little, unaligned>(d));
1114 break;
1115 case DeclarationName::ObjCZeroArgSelector:
1116 case DeclarationName::ObjCOneArgSelector:
1117 case DeclarationName::ObjCMultiArgSelector:
1118 Data =
1119 (uint64_t)Reader.getLocalSelector(
1120 F, endian::readNext<uint32_t, little, unaligned>(
1121 d)).getAsOpaquePtr();
1122 break;
1123 case DeclarationName::CXXOperatorName:
1124 Data = *d++; // OverloadedOperatorKind
1125 break;
1126 case DeclarationName::CXXConstructorName:
1127 case DeclarationName::CXXDestructorName:
1128 case DeclarationName::CXXConversionFunctionName:
1129 case DeclarationName::CXXUsingDirective:
1130 Data = 0;
1131 break;
1132 }
1133
1134 return DeclarationNameKey(Kind, Data);
1135 }
1136
ReadDataInto(internal_key_type,const unsigned char * d,unsigned DataLen,data_type_builder & Val)1137 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1138 const unsigned char *d,
1139 unsigned DataLen,
1140 data_type_builder &Val) {
1141 using namespace llvm::support;
1142
1143 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1144 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1145 Val.insert(Reader.getGlobalDeclID(F, LocalID));
1146 }
1147 }
1148
ReadLexicalDeclContextStorage(ModuleFile & M,BitstreamCursor & Cursor,uint64_t Offset,DeclContext * DC)1149 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1150 BitstreamCursor &Cursor,
1151 uint64_t Offset,
1152 DeclContext *DC) {
1153 assert(Offset != 0);
1154
1155 SavedStreamPosition SavedPosition(Cursor);
1156 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1157 Error(std::move(Err));
1158 return true;
1159 }
1160
1161 RecordData Record;
1162 StringRef Blob;
1163 Expected<unsigned> MaybeCode = Cursor.ReadCode();
1164 if (!MaybeCode) {
1165 Error(MaybeCode.takeError());
1166 return true;
1167 }
1168 unsigned Code = MaybeCode.get();
1169
1170 Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1171 if (!MaybeRecCode) {
1172 Error(MaybeRecCode.takeError());
1173 return true;
1174 }
1175 unsigned RecCode = MaybeRecCode.get();
1176 if (RecCode != DECL_CONTEXT_LEXICAL) {
1177 Error("Expected lexical block");
1178 return true;
1179 }
1180
1181 assert(!isa<TranslationUnitDecl>(DC) &&
1182 "expected a TU_UPDATE_LEXICAL record for TU");
1183 // If we are handling a C++ class template instantiation, we can see multiple
1184 // lexical updates for the same record. It's important that we select only one
1185 // of them, so that field numbering works properly. Just pick the first one we
1186 // see.
1187 auto &Lex = LexicalDecls[DC];
1188 if (!Lex.first) {
1189 Lex = std::make_pair(
1190 &M, llvm::makeArrayRef(
1191 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1192 Blob.data()),
1193 Blob.size() / 4));
1194 }
1195 DC->setHasExternalLexicalStorage(true);
1196 return false;
1197 }
1198
ReadVisibleDeclContextStorage(ModuleFile & M,BitstreamCursor & Cursor,uint64_t Offset,DeclID ID)1199 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1200 BitstreamCursor &Cursor,
1201 uint64_t Offset,
1202 DeclID ID) {
1203 assert(Offset != 0);
1204
1205 SavedStreamPosition SavedPosition(Cursor);
1206 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1207 Error(std::move(Err));
1208 return true;
1209 }
1210
1211 RecordData Record;
1212 StringRef Blob;
1213 Expected<unsigned> MaybeCode = Cursor.ReadCode();
1214 if (!MaybeCode) {
1215 Error(MaybeCode.takeError());
1216 return true;
1217 }
1218 unsigned Code = MaybeCode.get();
1219
1220 Expected<unsigned> MaybeRecCode = Cursor.readRecord(Code, Record, &Blob);
1221 if (!MaybeRecCode) {
1222 Error(MaybeRecCode.takeError());
1223 return true;
1224 }
1225 unsigned RecCode = MaybeRecCode.get();
1226 if (RecCode != DECL_CONTEXT_VISIBLE) {
1227 Error("Expected visible lookup table block");
1228 return true;
1229 }
1230
1231 // We can't safely determine the primary context yet, so delay attaching the
1232 // lookup table until we're done with recursive deserialization.
1233 auto *Data = (const unsigned char*)Blob.data();
1234 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1235 return false;
1236 }
1237
Error(StringRef Msg) const1238 void ASTReader::Error(StringRef Msg) const {
1239 Error(diag::err_fe_pch_malformed, Msg);
1240 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1241 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1242 Diag(diag::note_module_cache_path)
1243 << PP.getHeaderSearchInfo().getModuleCachePath();
1244 }
1245 }
1246
Error(unsigned DiagID,StringRef Arg1,StringRef Arg2,StringRef Arg3) const1247 void ASTReader::Error(unsigned DiagID, StringRef Arg1, StringRef Arg2,
1248 StringRef Arg3) const {
1249 if (Diags.isDiagnosticInFlight())
1250 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2, Arg3);
1251 else
1252 Diag(DiagID) << Arg1 << Arg2 << Arg3;
1253 }
1254
Error(unsigned DiagID,StringRef Arg1,StringRef Arg2,unsigned Select) const1255 void ASTReader::Error(unsigned DiagID, StringRef Arg1, StringRef Arg2,
1256 unsigned Select) const {
1257 if (!Diags.isDiagnosticInFlight())
1258 Diag(DiagID) << Arg1 << Arg2 << Select;
1259 }
1260
Error(llvm::Error && Err) const1261 void ASTReader::Error(llvm::Error &&Err) const {
1262 Error(toString(std::move(Err)));
1263 }
1264
1265 //===----------------------------------------------------------------------===//
1266 // Source Manager Deserialization
1267 //===----------------------------------------------------------------------===//
1268
1269 /// Read the line table in the source manager block.
1270 /// \returns true if there was an error.
ParseLineTable(ModuleFile & F,const RecordData & Record)1271 bool ASTReader::ParseLineTable(ModuleFile &F,
1272 const RecordData &Record) {
1273 unsigned Idx = 0;
1274 LineTableInfo &LineTable = SourceMgr.getLineTable();
1275
1276 // Parse the file names
1277 std::map<int, int> FileIDs;
1278 FileIDs[-1] = -1; // For unspecified filenames.
1279 for (unsigned I = 0; Record[Idx]; ++I) {
1280 // Extract the file name
1281 auto Filename = ReadPath(F, Record, Idx);
1282 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1283 }
1284 ++Idx;
1285
1286 // Parse the line entries
1287 std::vector<LineEntry> Entries;
1288 while (Idx < Record.size()) {
1289 int FID = Record[Idx++];
1290 assert(FID >= 0 && "Serialized line entries for non-local file.");
1291 // Remap FileID from 1-based old view.
1292 FID += F.SLocEntryBaseID - 1;
1293
1294 // Extract the line entries
1295 unsigned NumEntries = Record[Idx++];
1296 assert(NumEntries && "no line entries for file ID");
1297 Entries.clear();
1298 Entries.reserve(NumEntries);
1299 for (unsigned I = 0; I != NumEntries; ++I) {
1300 unsigned FileOffset = Record[Idx++];
1301 unsigned LineNo = Record[Idx++];
1302 int FilenameID = FileIDs[Record[Idx++]];
1303 SrcMgr::CharacteristicKind FileKind
1304 = (SrcMgr::CharacteristicKind)Record[Idx++];
1305 unsigned IncludeOffset = Record[Idx++];
1306 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1307 FileKind, IncludeOffset));
1308 }
1309 LineTable.AddEntry(FileID::get(FID), Entries);
1310 }
1311
1312 return false;
1313 }
1314
1315 /// Read a source manager block
ReadSourceManagerBlock(ModuleFile & F)1316 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1317 using namespace SrcMgr;
1318
1319 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1320
1321 // Set the source-location entry cursor to the current position in
1322 // the stream. This cursor will be used to read the contents of the
1323 // source manager block initially, and then lazily read
1324 // source-location entries as needed.
1325 SLocEntryCursor = F.Stream;
1326
1327 // The stream itself is going to skip over the source manager block.
1328 if (llvm::Error Err = F.Stream.SkipBlock()) {
1329 Error(std::move(Err));
1330 return true;
1331 }
1332
1333 // Enter the source manager block.
1334 if (llvm::Error Err =
1335 SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1336 Error(std::move(Err));
1337 return true;
1338 }
1339 F.SourceManagerBlockStartOffset = SLocEntryCursor.GetCurrentBitNo();
1340
1341 RecordData Record;
1342 while (true) {
1343 Expected<llvm::BitstreamEntry> MaybeE =
1344 SLocEntryCursor.advanceSkippingSubblocks();
1345 if (!MaybeE) {
1346 Error(MaybeE.takeError());
1347 return true;
1348 }
1349 llvm::BitstreamEntry E = MaybeE.get();
1350
1351 switch (E.Kind) {
1352 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1353 case llvm::BitstreamEntry::Error:
1354 Error("malformed block record in AST file");
1355 return true;
1356 case llvm::BitstreamEntry::EndBlock:
1357 return false;
1358 case llvm::BitstreamEntry::Record:
1359 // The interesting case.
1360 break;
1361 }
1362
1363 // Read a record.
1364 Record.clear();
1365 StringRef Blob;
1366 Expected<unsigned> MaybeRecord =
1367 SLocEntryCursor.readRecord(E.ID, Record, &Blob);
1368 if (!MaybeRecord) {
1369 Error(MaybeRecord.takeError());
1370 return true;
1371 }
1372 switch (MaybeRecord.get()) {
1373 default: // Default behavior: ignore.
1374 break;
1375
1376 case SM_SLOC_FILE_ENTRY:
1377 case SM_SLOC_BUFFER_ENTRY:
1378 case SM_SLOC_EXPANSION_ENTRY:
1379 // Once we hit one of the source location entries, we're done.
1380 return false;
1381 }
1382 }
1383 }
1384
1385 /// If a header file is not found at the path that we expect it to be
1386 /// and the PCH file was moved from its original location, try to resolve the
1387 /// file by assuming that header+PCH were moved together and the header is in
1388 /// the same place relative to the PCH.
1389 static std::string
resolveFileRelativeToOriginalDir(const std::string & Filename,const std::string & OriginalDir,const std::string & CurrDir)1390 resolveFileRelativeToOriginalDir(const std::string &Filename,
1391 const std::string &OriginalDir,
1392 const std::string &CurrDir) {
1393 assert(OriginalDir != CurrDir &&
1394 "No point trying to resolve the file if the PCH dir didn't change");
1395
1396 using namespace llvm::sys;
1397
1398 SmallString<128> filePath(Filename);
1399 fs::make_absolute(filePath);
1400 assert(path::is_absolute(OriginalDir));
1401 SmallString<128> currPCHPath(CurrDir);
1402
1403 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1404 fileDirE = path::end(path::parent_path(filePath));
1405 path::const_iterator origDirI = path::begin(OriginalDir),
1406 origDirE = path::end(OriginalDir);
1407 // Skip the common path components from filePath and OriginalDir.
1408 while (fileDirI != fileDirE && origDirI != origDirE &&
1409 *fileDirI == *origDirI) {
1410 ++fileDirI;
1411 ++origDirI;
1412 }
1413 for (; origDirI != origDirE; ++origDirI)
1414 path::append(currPCHPath, "..");
1415 path::append(currPCHPath, fileDirI, fileDirE);
1416 path::append(currPCHPath, path::filename(Filename));
1417 return std::string(currPCHPath.str());
1418 }
1419
ReadSLocEntry(int ID)1420 bool ASTReader::ReadSLocEntry(int ID) {
1421 if (ID == 0)
1422 return false;
1423
1424 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1425 Error("source location entry ID out-of-range for AST file");
1426 return true;
1427 }
1428
1429 // Local helper to read the (possibly-compressed) buffer data following the
1430 // entry record.
1431 auto ReadBuffer = [this](
1432 BitstreamCursor &SLocEntryCursor,
1433 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1434 RecordData Record;
1435 StringRef Blob;
1436 Expected<unsigned> MaybeCode = SLocEntryCursor.ReadCode();
1437 if (!MaybeCode) {
1438 Error(MaybeCode.takeError());
1439 return nullptr;
1440 }
1441 unsigned Code = MaybeCode.get();
1442
1443 Expected<unsigned> MaybeRecCode =
1444 SLocEntryCursor.readRecord(Code, Record, &Blob);
1445 if (!MaybeRecCode) {
1446 Error(MaybeRecCode.takeError());
1447 return nullptr;
1448 }
1449 unsigned RecCode = MaybeRecCode.get();
1450
1451 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1452 if (!llvm::zlib::isAvailable()) {
1453 Error("zlib is not available");
1454 return nullptr;
1455 }
1456 SmallString<0> Uncompressed;
1457 if (llvm::Error E =
1458 llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1459 Error("could not decompress embedded file contents: " +
1460 llvm::toString(std::move(E)));
1461 return nullptr;
1462 }
1463 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1464 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1465 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1466 } else {
1467 Error("AST record has invalid code");
1468 return nullptr;
1469 }
1470 };
1471
1472 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1473 if (llvm::Error Err = F->SLocEntryCursor.JumpToBit(
1474 F->SLocEntryOffsetsBase +
1475 F->SLocEntryOffsets[ID - F->SLocEntryBaseID])) {
1476 Error(std::move(Err));
1477 return true;
1478 }
1479
1480 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1481 unsigned BaseOffset = F->SLocEntryBaseOffset;
1482
1483 ++NumSLocEntriesRead;
1484 Expected<llvm::BitstreamEntry> MaybeEntry = SLocEntryCursor.advance();
1485 if (!MaybeEntry) {
1486 Error(MaybeEntry.takeError());
1487 return true;
1488 }
1489 llvm::BitstreamEntry Entry = MaybeEntry.get();
1490
1491 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1492 Error("incorrectly-formatted source location entry in AST file");
1493 return true;
1494 }
1495
1496 RecordData Record;
1497 StringRef Blob;
1498 Expected<unsigned> MaybeSLOC =
1499 SLocEntryCursor.readRecord(Entry.ID, Record, &Blob);
1500 if (!MaybeSLOC) {
1501 Error(MaybeSLOC.takeError());
1502 return true;
1503 }
1504 switch (MaybeSLOC.get()) {
1505 default:
1506 Error("incorrectly-formatted source location entry in AST file");
1507 return true;
1508
1509 case SM_SLOC_FILE_ENTRY: {
1510 // We will detect whether a file changed and return 'Failure' for it, but
1511 // we will also try to fail gracefully by setting up the SLocEntry.
1512 unsigned InputID = Record[4];
1513 InputFile IF = getInputFile(*F, InputID);
1514 const FileEntry *File = IF.getFile();
1515 bool OverriddenBuffer = IF.isOverridden();
1516
1517 // Note that we only check if a File was returned. If it was out-of-date
1518 // we have complained but we will continue creating a FileID to recover
1519 // gracefully.
1520 if (!File)
1521 return true;
1522
1523 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1524 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1525 // This is the module's main file.
1526 IncludeLoc = getImportLocation(F);
1527 }
1528 SrcMgr::CharacteristicKind
1529 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1530 // FIXME: The FileID should be created from the FileEntryRef.
1531 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1532 ID, BaseOffset + Record[0]);
1533 SrcMgr::FileInfo &FileInfo =
1534 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1535 FileInfo.NumCreatedFIDs = Record[5];
1536 if (Record[3])
1537 FileInfo.setHasLineDirectives();
1538
1539 unsigned NumFileDecls = Record[7];
1540 if (NumFileDecls && ContextObj) {
1541 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1542 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1543 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1544 NumFileDecls));
1545 }
1546
1547 const SrcMgr::ContentCache *ContentCache
1548 = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1549 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1550 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1551 !ContentCache->getRawBuffer()) {
1552 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1553 if (!Buffer)
1554 return true;
1555 SourceMgr.overrideFileContents(File, std::move(Buffer));
1556 }
1557
1558 break;
1559 }
1560
1561 case SM_SLOC_BUFFER_ENTRY: {
1562 const char *Name = Blob.data();
1563 unsigned Offset = Record[0];
1564 SrcMgr::CharacteristicKind
1565 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1566 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1567 if (IncludeLoc.isInvalid() && F->isModule()) {
1568 IncludeLoc = getImportLocation(F);
1569 }
1570
1571 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1572 if (!Buffer)
1573 return true;
1574 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1575 BaseOffset + Offset, IncludeLoc);
1576 break;
1577 }
1578
1579 case SM_SLOC_EXPANSION_ENTRY: {
1580 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1581 SourceMgr.createExpansionLoc(SpellingLoc,
1582 ReadSourceLocation(*F, Record[2]),
1583 ReadSourceLocation(*F, Record[3]),
1584 Record[5],
1585 Record[4],
1586 ID,
1587 BaseOffset + Record[0]);
1588 break;
1589 }
1590 }
1591
1592 return false;
1593 }
1594
getModuleImportLoc(int ID)1595 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1596 if (ID == 0)
1597 return std::make_pair(SourceLocation(), "");
1598
1599 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1600 Error("source location entry ID out-of-range for AST file");
1601 return std::make_pair(SourceLocation(), "");
1602 }
1603
1604 // Find which module file this entry lands in.
1605 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1606 if (!M->isModule())
1607 return std::make_pair(SourceLocation(), "");
1608
1609 // FIXME: Can we map this down to a particular submodule? That would be
1610 // ideal.
1611 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1612 }
1613
1614 /// Find the location where the module F is imported.
getImportLocation(ModuleFile * F)1615 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1616 if (F->ImportLoc.isValid())
1617 return F->ImportLoc;
1618
1619 // Otherwise we have a PCH. It's considered to be "imported" at the first
1620 // location of its includer.
1621 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1622 // Main file is the importer.
1623 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1624 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1625 }
1626 return F->ImportedBy[0]->FirstLoc;
1627 }
1628
1629 /// Enter a subblock of the specified BlockID with the specified cursor. Read
1630 /// the abbreviations that are at the top of the block and then leave the cursor
1631 /// pointing into the block.
ReadBlockAbbrevs(BitstreamCursor & Cursor,unsigned BlockID,uint64_t * StartOfBlockOffset)1632 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID,
1633 uint64_t *StartOfBlockOffset) {
1634 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
1635 // FIXME this drops errors on the floor.
1636 consumeError(std::move(Err));
1637 return true;
1638 }
1639
1640 if (StartOfBlockOffset)
1641 *StartOfBlockOffset = Cursor.GetCurrentBitNo();
1642
1643 while (true) {
1644 uint64_t Offset = Cursor.GetCurrentBitNo();
1645 Expected<unsigned> MaybeCode = Cursor.ReadCode();
1646 if (!MaybeCode) {
1647 // FIXME this drops errors on the floor.
1648 consumeError(MaybeCode.takeError());
1649 return true;
1650 }
1651 unsigned Code = MaybeCode.get();
1652
1653 // We expect all abbrevs to be at the start of the block.
1654 if (Code != llvm::bitc::DEFINE_ABBREV) {
1655 if (llvm::Error Err = Cursor.JumpToBit(Offset)) {
1656 // FIXME this drops errors on the floor.
1657 consumeError(std::move(Err));
1658 return true;
1659 }
1660 return false;
1661 }
1662 if (llvm::Error Err = Cursor.ReadAbbrevRecord()) {
1663 // FIXME this drops errors on the floor.
1664 consumeError(std::move(Err));
1665 return true;
1666 }
1667 }
1668 }
1669
ReadToken(ModuleFile & F,const RecordDataImpl & Record,unsigned & Idx)1670 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1671 unsigned &Idx) {
1672 Token Tok;
1673 Tok.startToken();
1674 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1675 Tok.setLength(Record[Idx++]);
1676 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1677 Tok.setIdentifierInfo(II);
1678 Tok.setKind((tok::TokenKind)Record[Idx++]);
1679 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1680 return Tok;
1681 }
1682
ReadMacroRecord(ModuleFile & F,uint64_t Offset)1683 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1684 BitstreamCursor &Stream = F.MacroCursor;
1685
1686 // Keep track of where we are in the stream, then jump back there
1687 // after reading this macro.
1688 SavedStreamPosition SavedPosition(Stream);
1689
1690 if (llvm::Error Err = Stream.JumpToBit(Offset)) {
1691 // FIXME this drops errors on the floor.
1692 consumeError(std::move(Err));
1693 return nullptr;
1694 }
1695 RecordData Record;
1696 SmallVector<IdentifierInfo*, 16> MacroParams;
1697 MacroInfo *Macro = nullptr;
1698
1699 while (true) {
1700 // Advance to the next record, but if we get to the end of the block, don't
1701 // pop it (removing all the abbreviations from the cursor) since we want to
1702 // be able to reseek within the block and read entries.
1703 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1704 Expected<llvm::BitstreamEntry> MaybeEntry =
1705 Stream.advanceSkippingSubblocks(Flags);
1706 if (!MaybeEntry) {
1707 Error(MaybeEntry.takeError());
1708 return Macro;
1709 }
1710 llvm::BitstreamEntry Entry = MaybeEntry.get();
1711
1712 switch (Entry.Kind) {
1713 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1714 case llvm::BitstreamEntry::Error:
1715 Error("malformed block record in AST file");
1716 return Macro;
1717 case llvm::BitstreamEntry::EndBlock:
1718 return Macro;
1719 case llvm::BitstreamEntry::Record:
1720 // The interesting case.
1721 break;
1722 }
1723
1724 // Read a record.
1725 Record.clear();
1726 PreprocessorRecordTypes RecType;
1727 if (Expected<unsigned> MaybeRecType = Stream.readRecord(Entry.ID, Record))
1728 RecType = (PreprocessorRecordTypes)MaybeRecType.get();
1729 else {
1730 Error(MaybeRecType.takeError());
1731 return Macro;
1732 }
1733 switch (RecType) {
1734 case PP_MODULE_MACRO:
1735 case PP_MACRO_DIRECTIVE_HISTORY:
1736 return Macro;
1737
1738 case PP_MACRO_OBJECT_LIKE:
1739 case PP_MACRO_FUNCTION_LIKE: {
1740 // If we already have a macro, that means that we've hit the end
1741 // of the definition of the macro we were looking for. We're
1742 // done.
1743 if (Macro)
1744 return Macro;
1745
1746 unsigned NextIndex = 1; // Skip identifier ID.
1747 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1748 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1749 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1750 MI->setIsUsed(Record[NextIndex++]);
1751 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1752
1753 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1754 // Decode function-like macro info.
1755 bool isC99VarArgs = Record[NextIndex++];
1756 bool isGNUVarArgs = Record[NextIndex++];
1757 bool hasCommaPasting = Record[NextIndex++];
1758 MacroParams.clear();
1759 unsigned NumArgs = Record[NextIndex++];
1760 for (unsigned i = 0; i != NumArgs; ++i)
1761 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1762
1763 // Install function-like macro info.
1764 MI->setIsFunctionLike();
1765 if (isC99VarArgs) MI->setIsC99Varargs();
1766 if (isGNUVarArgs) MI->setIsGNUVarargs();
1767 if (hasCommaPasting) MI->setHasCommaPasting();
1768 MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1769 }
1770
1771 // Remember that we saw this macro last so that we add the tokens that
1772 // form its body to it.
1773 Macro = MI;
1774
1775 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1776 Record[NextIndex]) {
1777 // We have a macro definition. Register the association
1778 PreprocessedEntityID
1779 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1780 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1781 PreprocessingRecord::PPEntityID PPID =
1782 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1783 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1784 PPRec.getPreprocessedEntity(PPID));
1785 if (PPDef)
1786 PPRec.RegisterMacroDefinition(Macro, PPDef);
1787 }
1788
1789 ++NumMacrosRead;
1790 break;
1791 }
1792
1793 case PP_TOKEN: {
1794 // If we see a TOKEN before a PP_MACRO_*, then the file is
1795 // erroneous, just pretend we didn't see this.
1796 if (!Macro) break;
1797
1798 unsigned Idx = 0;
1799 Token Tok = ReadToken(F, Record, Idx);
1800 Macro->AddTokenToBody(Tok);
1801 break;
1802 }
1803 }
1804 }
1805 }
1806
1807 PreprocessedEntityID
getGlobalPreprocessedEntityID(ModuleFile & M,unsigned LocalID) const1808 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1809 unsigned LocalID) const {
1810 if (!M.ModuleOffsetMap.empty())
1811 ReadModuleOffsetMap(M);
1812
1813 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1814 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1815 assert(I != M.PreprocessedEntityRemap.end()
1816 && "Invalid index into preprocessed entity index remap");
1817
1818 return LocalID + I->second;
1819 }
1820
ComputeHash(internal_key_ref ikey)1821 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1822 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1823 }
1824
1825 HeaderFileInfoTrait::internal_key_type
GetInternalKey(const FileEntry * FE)1826 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1827 internal_key_type ikey = {FE->getSize(),
1828 M.HasTimestamps ? FE->getModificationTime() : 0,
1829 FE->getName(), /*Imported*/ false};
1830 return ikey;
1831 }
1832
EqualKey(internal_key_ref a,internal_key_ref b)1833 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1834 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1835 return false;
1836
1837 if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1838 return true;
1839
1840 // Determine whether the actual files are equivalent.
1841 FileManager &FileMgr = Reader.getFileManager();
1842 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1843 if (!Key.Imported) {
1844 if (auto File = FileMgr.getFile(Key.Filename))
1845 return *File;
1846 return nullptr;
1847 }
1848
1849 std::string Resolved = std::string(Key.Filename);
1850 Reader.ResolveImportedPath(M, Resolved);
1851 if (auto File = FileMgr.getFile(Resolved))
1852 return *File;
1853 return nullptr;
1854 };
1855
1856 const FileEntry *FEA = GetFile(a);
1857 const FileEntry *FEB = GetFile(b);
1858 return FEA && FEA == FEB;
1859 }
1860
1861 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)1862 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1863 using namespace llvm::support;
1864
1865 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1866 unsigned DataLen = (unsigned) *d++;
1867 return std::make_pair(KeyLen, DataLen);
1868 }
1869
1870 HeaderFileInfoTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)1871 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1872 using namespace llvm::support;
1873
1874 internal_key_type ikey;
1875 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1876 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1877 ikey.Filename = (const char *)d;
1878 ikey.Imported = true;
1879 return ikey;
1880 }
1881
1882 HeaderFileInfoTrait::data_type
ReadData(internal_key_ref key,const unsigned char * d,unsigned DataLen)1883 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1884 unsigned DataLen) {
1885 using namespace llvm::support;
1886
1887 const unsigned char *End = d + DataLen;
1888 HeaderFileInfo HFI;
1889 unsigned Flags = *d++;
1890 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1891 HFI.isImport |= (Flags >> 5) & 0x01;
1892 HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1893 HFI.DirInfo = (Flags >> 1) & 0x07;
1894 HFI.IndexHeaderMapHeader = Flags & 0x01;
1895 // FIXME: Find a better way to handle this. Maybe just store a
1896 // "has been included" flag?
1897 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1898 HFI.NumIncludes);
1899 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1900 M, endian::readNext<uint32_t, little, unaligned>(d));
1901 if (unsigned FrameworkOffset =
1902 endian::readNext<uint32_t, little, unaligned>(d)) {
1903 // The framework offset is 1 greater than the actual offset,
1904 // since 0 is used as an indicator for "no framework name".
1905 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1906 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1907 }
1908
1909 assert((End - d) % 4 == 0 &&
1910 "Wrong data length in HeaderFileInfo deserialization");
1911 while (d != End) {
1912 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1913 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1914 LocalSMID >>= 2;
1915
1916 // This header is part of a module. Associate it with the module to enable
1917 // implicit module import.
1918 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1919 Module *Mod = Reader.getSubmodule(GlobalSMID);
1920 FileManager &FileMgr = Reader.getFileManager();
1921 ModuleMap &ModMap =
1922 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1923
1924 std::string Filename = std::string(key.Filename);
1925 if (key.Imported)
1926 Reader.ResolveImportedPath(M, Filename);
1927 // FIXME: This is not always the right filename-as-written, but we're not
1928 // going to use this information to rebuild the module, so it doesn't make
1929 // a lot of difference.
1930 Module::Header H = {std::string(key.Filename), *FileMgr.getFile(Filename)};
1931 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1932 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1933 }
1934
1935 // This HeaderFileInfo was externally loaded.
1936 HFI.External = true;
1937 HFI.IsValid = true;
1938 return HFI;
1939 }
1940
addPendingMacro(IdentifierInfo * II,ModuleFile * M,uint32_t MacroDirectivesOffset)1941 void ASTReader::addPendingMacro(IdentifierInfo *II, ModuleFile *M,
1942 uint32_t MacroDirectivesOffset) {
1943 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1944 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1945 }
1946
ReadDefinedMacros()1947 void ASTReader::ReadDefinedMacros() {
1948 // Note that we are loading defined macros.
1949 Deserializing Macros(this);
1950
1951 for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1952 BitstreamCursor &MacroCursor = I.MacroCursor;
1953
1954 // If there was no preprocessor block, skip this file.
1955 if (MacroCursor.getBitcodeBytes().empty())
1956 continue;
1957
1958 BitstreamCursor Cursor = MacroCursor;
1959 if (llvm::Error Err = Cursor.JumpToBit(I.MacroStartOffset)) {
1960 Error(std::move(Err));
1961 return;
1962 }
1963
1964 RecordData Record;
1965 while (true) {
1966 Expected<llvm::BitstreamEntry> MaybeE = Cursor.advanceSkippingSubblocks();
1967 if (!MaybeE) {
1968 Error(MaybeE.takeError());
1969 return;
1970 }
1971 llvm::BitstreamEntry E = MaybeE.get();
1972
1973 switch (E.Kind) {
1974 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1975 case llvm::BitstreamEntry::Error:
1976 Error("malformed block record in AST file");
1977 return;
1978 case llvm::BitstreamEntry::EndBlock:
1979 goto NextCursor;
1980
1981 case llvm::BitstreamEntry::Record: {
1982 Record.clear();
1983 Expected<unsigned> MaybeRecord = Cursor.readRecord(E.ID, Record);
1984 if (!MaybeRecord) {
1985 Error(MaybeRecord.takeError());
1986 return;
1987 }
1988 switch (MaybeRecord.get()) {
1989 default: // Default behavior: ignore.
1990 break;
1991
1992 case PP_MACRO_OBJECT_LIKE:
1993 case PP_MACRO_FUNCTION_LIKE: {
1994 IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1995 if (II->isOutOfDate())
1996 updateOutOfDateIdentifier(*II);
1997 break;
1998 }
1999
2000 case PP_TOKEN:
2001 // Ignore tokens.
2002 break;
2003 }
2004 break;
2005 }
2006 }
2007 }
2008 NextCursor: ;
2009 }
2010 }
2011
2012 namespace {
2013
2014 /// Visitor class used to look up identifirs in an AST file.
2015 class IdentifierLookupVisitor {
2016 StringRef Name;
2017 unsigned NameHash;
2018 unsigned PriorGeneration;
2019 unsigned &NumIdentifierLookups;
2020 unsigned &NumIdentifierLookupHits;
2021 IdentifierInfo *Found = nullptr;
2022
2023 public:
IdentifierLookupVisitor(StringRef Name,unsigned PriorGeneration,unsigned & NumIdentifierLookups,unsigned & NumIdentifierLookupHits)2024 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
2025 unsigned &NumIdentifierLookups,
2026 unsigned &NumIdentifierLookupHits)
2027 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
2028 PriorGeneration(PriorGeneration),
2029 NumIdentifierLookups(NumIdentifierLookups),
2030 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
2031
operator ()(ModuleFile & M)2032 bool operator()(ModuleFile &M) {
2033 // If we've already searched this module file, skip it now.
2034 if (M.Generation <= PriorGeneration)
2035 return true;
2036
2037 ASTIdentifierLookupTable *IdTable
2038 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
2039 if (!IdTable)
2040 return false;
2041
2042 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
2043 Found);
2044 ++NumIdentifierLookups;
2045 ASTIdentifierLookupTable::iterator Pos =
2046 IdTable->find_hashed(Name, NameHash, &Trait);
2047 if (Pos == IdTable->end())
2048 return false;
2049
2050 // Dereferencing the iterator has the effect of building the
2051 // IdentifierInfo node and populating it with the various
2052 // declarations it needs.
2053 ++NumIdentifierLookupHits;
2054 Found = *Pos;
2055 return true;
2056 }
2057
2058 // Retrieve the identifier info found within the module
2059 // files.
getIdentifierInfo() const2060 IdentifierInfo *getIdentifierInfo() const { return Found; }
2061 };
2062
2063 } // namespace
2064
updateOutOfDateIdentifier(IdentifierInfo & II)2065 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
2066 // Note that we are loading an identifier.
2067 Deserializing AnIdentifier(this);
2068
2069 unsigned PriorGeneration = 0;
2070 if (getContext().getLangOpts().Modules)
2071 PriorGeneration = IdentifierGeneration[&II];
2072
2073 // If there is a global index, look there first to determine which modules
2074 // provably do not have any results for this identifier.
2075 GlobalModuleIndex::HitSet Hits;
2076 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
2077 if (!loadGlobalIndex()) {
2078 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
2079 HitsPtr = &Hits;
2080 }
2081 }
2082
2083 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
2084 NumIdentifierLookups,
2085 NumIdentifierLookupHits);
2086 ModuleMgr.visit(Visitor, HitsPtr);
2087 markIdentifierUpToDate(&II);
2088 }
2089
markIdentifierUpToDate(IdentifierInfo * II)2090 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
2091 if (!II)
2092 return;
2093
2094 II->setOutOfDate(false);
2095
2096 // Update the generation for this identifier.
2097 if (getContext().getLangOpts().Modules)
2098 IdentifierGeneration[II] = getGeneration();
2099 }
2100
resolvePendingMacro(IdentifierInfo * II,const PendingMacroInfo & PMInfo)2101 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
2102 const PendingMacroInfo &PMInfo) {
2103 ModuleFile &M = *PMInfo.M;
2104
2105 BitstreamCursor &Cursor = M.MacroCursor;
2106 SavedStreamPosition SavedPosition(Cursor);
2107 if (llvm::Error Err =
2108 Cursor.JumpToBit(M.MacroOffsetsBase + PMInfo.MacroDirectivesOffset)) {
2109 Error(std::move(Err));
2110 return;
2111 }
2112
2113 struct ModuleMacroRecord {
2114 SubmoduleID SubModID;
2115 MacroInfo *MI;
2116 SmallVector<SubmoduleID, 8> Overrides;
2117 };
2118 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
2119
2120 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
2121 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
2122 // macro histroy.
2123 RecordData Record;
2124 while (true) {
2125 Expected<llvm::BitstreamEntry> MaybeEntry =
2126 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
2127 if (!MaybeEntry) {
2128 Error(MaybeEntry.takeError());
2129 return;
2130 }
2131 llvm::BitstreamEntry Entry = MaybeEntry.get();
2132
2133 if (Entry.Kind != llvm::BitstreamEntry::Record) {
2134 Error("malformed block record in AST file");
2135 return;
2136 }
2137
2138 Record.clear();
2139 Expected<unsigned> MaybePP = Cursor.readRecord(Entry.ID, Record);
2140 if (!MaybePP) {
2141 Error(MaybePP.takeError());
2142 return;
2143 }
2144 switch ((PreprocessorRecordTypes)MaybePP.get()) {
2145 case PP_MACRO_DIRECTIVE_HISTORY:
2146 break;
2147
2148 case PP_MODULE_MACRO: {
2149 ModuleMacros.push_back(ModuleMacroRecord());
2150 auto &Info = ModuleMacros.back();
2151 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
2152 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
2153 for (int I = 2, N = Record.size(); I != N; ++I)
2154 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
2155 continue;
2156 }
2157
2158 default:
2159 Error("malformed block record in AST file");
2160 return;
2161 }
2162
2163 // We found the macro directive history; that's the last record
2164 // for this macro.
2165 break;
2166 }
2167
2168 // Module macros are listed in reverse dependency order.
2169 {
2170 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2171 llvm::SmallVector<ModuleMacro*, 8> Overrides;
2172 for (auto &MMR : ModuleMacros) {
2173 Overrides.clear();
2174 for (unsigned ModID : MMR.Overrides) {
2175 Module *Mod = getSubmodule(ModID);
2176 auto *Macro = PP.getModuleMacro(Mod, II);
2177 assert(Macro && "missing definition for overridden macro");
2178 Overrides.push_back(Macro);
2179 }
2180
2181 bool Inserted = false;
2182 Module *Owner = getSubmodule(MMR.SubModID);
2183 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2184 }
2185 }
2186
2187 // Don't read the directive history for a module; we don't have anywhere
2188 // to put it.
2189 if (M.isModule())
2190 return;
2191
2192 // Deserialize the macro directives history in reverse source-order.
2193 MacroDirective *Latest = nullptr, *Earliest = nullptr;
2194 unsigned Idx = 0, N = Record.size();
2195 while (Idx < N) {
2196 MacroDirective *MD = nullptr;
2197 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2198 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2199 switch (K) {
2200 case MacroDirective::MD_Define: {
2201 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2202 MD = PP.AllocateDefMacroDirective(MI, Loc);
2203 break;
2204 }
2205 case MacroDirective::MD_Undefine:
2206 MD = PP.AllocateUndefMacroDirective(Loc);
2207 break;
2208 case MacroDirective::MD_Visibility:
2209 bool isPublic = Record[Idx++];
2210 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2211 break;
2212 }
2213
2214 if (!Latest)
2215 Latest = MD;
2216 if (Earliest)
2217 Earliest->setPrevious(MD);
2218 Earliest = MD;
2219 }
2220
2221 if (Latest)
2222 PP.setLoadedMacroDirective(II, Earliest, Latest);
2223 }
2224
2225 ASTReader::InputFileInfo
readInputFileInfo(ModuleFile & F,unsigned ID)2226 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2227 // Go find this input file.
2228 BitstreamCursor &Cursor = F.InputFilesCursor;
2229 SavedStreamPosition SavedPosition(Cursor);
2230 if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2231 // FIXME this drops errors on the floor.
2232 consumeError(std::move(Err));
2233 }
2234
2235 Expected<unsigned> MaybeCode = Cursor.ReadCode();
2236 if (!MaybeCode) {
2237 // FIXME this drops errors on the floor.
2238 consumeError(MaybeCode.takeError());
2239 }
2240 unsigned Code = MaybeCode.get();
2241 RecordData Record;
2242 StringRef Blob;
2243
2244 if (Expected<unsigned> Maybe = Cursor.readRecord(Code, Record, &Blob))
2245 assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE &&
2246 "invalid record type for input file");
2247 else {
2248 // FIXME this drops errors on the floor.
2249 consumeError(Maybe.takeError());
2250 }
2251
2252 assert(Record[0] == ID && "Bogus stored ID or offset");
2253 InputFileInfo R;
2254 R.StoredSize = static_cast<off_t>(Record[1]);
2255 R.StoredTime = static_cast<time_t>(Record[2]);
2256 R.Overridden = static_cast<bool>(Record[3]);
2257 R.Transient = static_cast<bool>(Record[4]);
2258 R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2259 R.Filename = std::string(Blob);
2260 ResolveImportedPath(F, R.Filename);
2261
2262 Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
2263 if (!MaybeEntry) // FIXME this drops errors on the floor.
2264 consumeError(MaybeEntry.takeError());
2265 llvm::BitstreamEntry Entry = MaybeEntry.get();
2266 assert(Entry.Kind == llvm::BitstreamEntry::Record &&
2267 "expected record type for input file hash");
2268
2269 Record.clear();
2270 if (Expected<unsigned> Maybe = Cursor.readRecord(Entry.ID, Record))
2271 assert(static_cast<InputFileRecordTypes>(Maybe.get()) == INPUT_FILE_HASH &&
2272 "invalid record type for input file hash");
2273 else {
2274 // FIXME this drops errors on the floor.
2275 consumeError(Maybe.takeError());
2276 }
2277 R.ContentHash = (static_cast<uint64_t>(Record[1]) << 32) |
2278 static_cast<uint64_t>(Record[0]);
2279 return R;
2280 }
2281
2282 static unsigned moduleKindForDiagnostic(ModuleKind Kind);
getInputFile(ModuleFile & F,unsigned ID,bool Complain)2283 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2284 // If this ID is bogus, just return an empty input file.
2285 if (ID == 0 || ID > F.InputFilesLoaded.size())
2286 return InputFile();
2287
2288 // If we've already loaded this input file, return it.
2289 if (F.InputFilesLoaded[ID-1].getFile())
2290 return F.InputFilesLoaded[ID-1];
2291
2292 if (F.InputFilesLoaded[ID-1].isNotFound())
2293 return InputFile();
2294
2295 // Go find this input file.
2296 BitstreamCursor &Cursor = F.InputFilesCursor;
2297 SavedStreamPosition SavedPosition(Cursor);
2298 if (llvm::Error Err = Cursor.JumpToBit(F.InputFileOffsets[ID - 1])) {
2299 // FIXME this drops errors on the floor.
2300 consumeError(std::move(Err));
2301 }
2302
2303 InputFileInfo FI = readInputFileInfo(F, ID);
2304 off_t StoredSize = FI.StoredSize;
2305 time_t StoredTime = FI.StoredTime;
2306 bool Overridden = FI.Overridden;
2307 bool Transient = FI.Transient;
2308 StringRef Filename = FI.Filename;
2309 uint64_t StoredContentHash = FI.ContentHash;
2310
2311 const FileEntry *File = nullptr;
2312 if (auto FE = FileMgr.getFile(Filename, /*OpenFile=*/false))
2313 File = *FE;
2314
2315 // If we didn't find the file, resolve it relative to the
2316 // original directory from which this AST file was created.
2317 if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2318 F.OriginalDir != F.BaseDirectory) {
2319 std::string Resolved = resolveFileRelativeToOriginalDir(
2320 std::string(Filename), F.OriginalDir, F.BaseDirectory);
2321 if (!Resolved.empty())
2322 if (auto FE = FileMgr.getFile(Resolved))
2323 File = *FE;
2324 }
2325
2326 // For an overridden file, create a virtual file with the stored
2327 // size/timestamp.
2328 if ((Overridden || Transient) && File == nullptr)
2329 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2330
2331 if (File == nullptr) {
2332 if (Complain) {
2333 std::string ErrorStr = "could not find file '";
2334 ErrorStr += Filename;
2335 ErrorStr += "' referenced by AST file '";
2336 ErrorStr += F.FileName;
2337 ErrorStr += "'";
2338 Error(ErrorStr);
2339 }
2340 // Record that we didn't find the file.
2341 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2342 return InputFile();
2343 }
2344
2345 // Check if there was a request to override the contents of the file
2346 // that was part of the precompiled header. Overriding such a file
2347 // can lead to problems when lexing using the source locations from the
2348 // PCH.
2349 SourceManager &SM = getSourceManager();
2350 // FIXME: Reject if the overrides are different.
2351 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2352 if (Complain)
2353 Error(diag::err_fe_pch_file_overridden, Filename);
2354
2355 // After emitting the diagnostic, bypass the overriding file to recover
2356 // (this creates a separate FileEntry).
2357 File = SM.bypassFileContentsOverride(*File);
2358 if (!File) {
2359 F.InputFilesLoaded[ID - 1] = InputFile::getNotFound();
2360 return InputFile();
2361 }
2362 }
2363
2364 enum ModificationType {
2365 Size,
2366 ModTime,
2367 Content,
2368 None,
2369 };
2370 auto HasInputFileChanged = [&]() {
2371 if (StoredSize != File->getSize())
2372 return ModificationType::Size;
2373 if (!DisableValidation && StoredTime &&
2374 StoredTime != File->getModificationTime()) {
2375 // In case the modification time changes but not the content,
2376 // accept the cached file as legit.
2377 if (ValidateASTInputFilesContent &&
2378 StoredContentHash != static_cast<uint64_t>(llvm::hash_code(-1))) {
2379 auto MemBuffOrError = FileMgr.getBufferForFile(File);
2380 if (!MemBuffOrError) {
2381 if (!Complain)
2382 return ModificationType::ModTime;
2383 std::string ErrorStr = "could not get buffer for file '";
2384 ErrorStr += File->getName();
2385 ErrorStr += "'";
2386 Error(ErrorStr);
2387 return ModificationType::ModTime;
2388 }
2389
2390 auto ContentHash = hash_value(MemBuffOrError.get()->getBuffer());
2391 if (StoredContentHash == static_cast<uint64_t>(ContentHash))
2392 return ModificationType::None;
2393 return ModificationType::Content;
2394 }
2395 return ModificationType::ModTime;
2396 }
2397 return ModificationType::None;
2398 };
2399
2400 bool IsOutOfDate = false;
2401 auto FileChange = HasInputFileChanged();
2402 // For an overridden file, there is nothing to validate.
2403 if (!Overridden && FileChange != ModificationType::None) {
2404 if (Complain) {
2405 // Build a list of the PCH imports that got us here (in reverse).
2406 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2407 while (!ImportStack.back()->ImportedBy.empty())
2408 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2409
2410 // The top-level PCH is stale.
2411 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2412 unsigned DiagnosticKind =
2413 moduleKindForDiagnostic(ImportStack.back()->Kind);
2414 if (DiagnosticKind == 0)
2415 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName,
2416 (unsigned)FileChange);
2417 else if (DiagnosticKind == 1)
2418 Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName,
2419 (unsigned)FileChange);
2420 else
2421 Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName,
2422 (unsigned)FileChange);
2423
2424 // Print the import stack.
2425 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2426 Diag(diag::note_pch_required_by)
2427 << Filename << ImportStack[0]->FileName;
2428 for (unsigned I = 1; I < ImportStack.size(); ++I)
2429 Diag(diag::note_pch_required_by)
2430 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2431 }
2432
2433 if (!Diags.isDiagnosticInFlight())
2434 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2435 }
2436
2437 IsOutOfDate = true;
2438 }
2439 // FIXME: If the file is overridden and we've already opened it,
2440 // issue an error (or split it into a separate FileEntry).
2441
2442 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2443
2444 // Note that we've loaded this input file.
2445 F.InputFilesLoaded[ID-1] = IF;
2446 return IF;
2447 }
2448
2449 /// If we are loading a relocatable PCH or module file, and the filename
2450 /// is not an absolute path, add the system or module root to the beginning of
2451 /// the file name.
ResolveImportedPath(ModuleFile & M,std::string & Filename)2452 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2453 // Resolve relative to the base directory, if we have one.
2454 if (!M.BaseDirectory.empty())
2455 return ResolveImportedPath(Filename, M.BaseDirectory);
2456 }
2457
ResolveImportedPath(std::string & Filename,StringRef Prefix)2458 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2459 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2460 return;
2461
2462 SmallString<128> Buffer;
2463 llvm::sys::path::append(Buffer, Prefix, Filename);
2464 Filename.assign(Buffer.begin(), Buffer.end());
2465 }
2466
isDiagnosedResult(ASTReader::ASTReadResult ARR,unsigned Caps)2467 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2468 switch (ARR) {
2469 case ASTReader::Failure: return true;
2470 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2471 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2472 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2473 case ASTReader::ConfigurationMismatch:
2474 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2475 case ASTReader::HadErrors: return true;
2476 case ASTReader::Success: return false;
2477 }
2478
2479 llvm_unreachable("unknown ASTReadResult");
2480 }
2481
ReadOptionsBlock(BitstreamCursor & Stream,unsigned ClientLoadCapabilities,bool AllowCompatibleConfigurationMismatch,ASTReaderListener & Listener,std::string & SuggestedPredefines)2482 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2483 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2484 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2485 std::string &SuggestedPredefines) {
2486 if (llvm::Error Err = Stream.EnterSubBlock(OPTIONS_BLOCK_ID)) {
2487 // FIXME this drops errors on the floor.
2488 consumeError(std::move(Err));
2489 return Failure;
2490 }
2491
2492 // Read all of the records in the options block.
2493 RecordData Record;
2494 ASTReadResult Result = Success;
2495 while (true) {
2496 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2497 if (!MaybeEntry) {
2498 // FIXME this drops errors on the floor.
2499 consumeError(MaybeEntry.takeError());
2500 return Failure;
2501 }
2502 llvm::BitstreamEntry Entry = MaybeEntry.get();
2503
2504 switch (Entry.Kind) {
2505 case llvm::BitstreamEntry::Error:
2506 case llvm::BitstreamEntry::SubBlock:
2507 return Failure;
2508
2509 case llvm::BitstreamEntry::EndBlock:
2510 return Result;
2511
2512 case llvm::BitstreamEntry::Record:
2513 // The interesting case.
2514 break;
2515 }
2516
2517 // Read and process a record.
2518 Record.clear();
2519 Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
2520 if (!MaybeRecordType) {
2521 // FIXME this drops errors on the floor.
2522 consumeError(MaybeRecordType.takeError());
2523 return Failure;
2524 }
2525 switch ((OptionsRecordTypes)MaybeRecordType.get()) {
2526 case LANGUAGE_OPTIONS: {
2527 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2528 if (ParseLanguageOptions(Record, Complain, Listener,
2529 AllowCompatibleConfigurationMismatch))
2530 Result = ConfigurationMismatch;
2531 break;
2532 }
2533
2534 case TARGET_OPTIONS: {
2535 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2536 if (ParseTargetOptions(Record, Complain, Listener,
2537 AllowCompatibleConfigurationMismatch))
2538 Result = ConfigurationMismatch;
2539 break;
2540 }
2541
2542 case FILE_SYSTEM_OPTIONS: {
2543 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2544 if (!AllowCompatibleConfigurationMismatch &&
2545 ParseFileSystemOptions(Record, Complain, Listener))
2546 Result = ConfigurationMismatch;
2547 break;
2548 }
2549
2550 case HEADER_SEARCH_OPTIONS: {
2551 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2552 if (!AllowCompatibleConfigurationMismatch &&
2553 ParseHeaderSearchOptions(Record, Complain, Listener))
2554 Result = ConfigurationMismatch;
2555 break;
2556 }
2557
2558 case PREPROCESSOR_OPTIONS:
2559 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2560 if (!AllowCompatibleConfigurationMismatch &&
2561 ParsePreprocessorOptions(Record, Complain, Listener,
2562 SuggestedPredefines))
2563 Result = ConfigurationMismatch;
2564 break;
2565 }
2566 }
2567 }
2568
2569 ASTReader::ASTReadResult
ReadControlBlock(ModuleFile & F,SmallVectorImpl<ImportedModule> & Loaded,const ModuleFile * ImportedBy,unsigned ClientLoadCapabilities)2570 ASTReader::ReadControlBlock(ModuleFile &F,
2571 SmallVectorImpl<ImportedModule> &Loaded,
2572 const ModuleFile *ImportedBy,
2573 unsigned ClientLoadCapabilities) {
2574 BitstreamCursor &Stream = F.Stream;
2575
2576 if (llvm::Error Err = Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2577 Error(std::move(Err));
2578 return Failure;
2579 }
2580
2581 // Lambda to read the unhashed control block the first time it's called.
2582 //
2583 // For PCM files, the unhashed control block cannot be read until after the
2584 // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2585 // need to look ahead before reading the IMPORTS record. For consistency,
2586 // this block is always read somehow (see BitstreamEntry::EndBlock).
2587 bool HasReadUnhashedControlBlock = false;
2588 auto readUnhashedControlBlockOnce = [&]() {
2589 if (!HasReadUnhashedControlBlock) {
2590 HasReadUnhashedControlBlock = true;
2591 if (ASTReadResult Result =
2592 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2593 return Result;
2594 }
2595 return Success;
2596 };
2597
2598 // Read all of the records and blocks in the control block.
2599 RecordData Record;
2600 unsigned NumInputs = 0;
2601 unsigned NumUserInputs = 0;
2602 StringRef BaseDirectoryAsWritten;
2603 while (true) {
2604 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2605 if (!MaybeEntry) {
2606 Error(MaybeEntry.takeError());
2607 return Failure;
2608 }
2609 llvm::BitstreamEntry Entry = MaybeEntry.get();
2610
2611 switch (Entry.Kind) {
2612 case llvm::BitstreamEntry::Error:
2613 Error("malformed block record in AST file");
2614 return Failure;
2615 case llvm::BitstreamEntry::EndBlock: {
2616 // Validate the module before returning. This call catches an AST with
2617 // no module name and no imports.
2618 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2619 return Result;
2620
2621 // Validate input files.
2622 const HeaderSearchOptions &HSOpts =
2623 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2624
2625 // All user input files reside at the index range [0, NumUserInputs), and
2626 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2627 // loaded module files, ignore missing inputs.
2628 if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2629 F.Kind != MK_PrebuiltModule) {
2630 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2631
2632 // If we are reading a module, we will create a verification timestamp,
2633 // so we verify all input files. Otherwise, verify only user input
2634 // files.
2635
2636 unsigned N = NumUserInputs;
2637 if (ValidateSystemInputs ||
2638 (HSOpts.ModulesValidateOncePerBuildSession &&
2639 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2640 F.Kind == MK_ImplicitModule))
2641 N = NumInputs;
2642
2643 for (unsigned I = 0; I < N; ++I) {
2644 InputFile IF = getInputFile(F, I+1, Complain);
2645 if (!IF.getFile() || IF.isOutOfDate())
2646 return OutOfDate;
2647 }
2648 }
2649
2650 if (Listener)
2651 Listener->visitModuleFile(F.FileName, F.Kind);
2652
2653 if (Listener && Listener->needsInputFileVisitation()) {
2654 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2655 : NumUserInputs;
2656 for (unsigned I = 0; I < N; ++I) {
2657 bool IsSystem = I >= NumUserInputs;
2658 InputFileInfo FI = readInputFileInfo(F, I+1);
2659 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2660 F.Kind == MK_ExplicitModule ||
2661 F.Kind == MK_PrebuiltModule);
2662 }
2663 }
2664
2665 return Success;
2666 }
2667
2668 case llvm::BitstreamEntry::SubBlock:
2669 switch (Entry.ID) {
2670 case INPUT_FILES_BLOCK_ID:
2671 F.InputFilesCursor = Stream;
2672 if (llvm::Error Err = Stream.SkipBlock()) {
2673 Error(std::move(Err));
2674 return Failure;
2675 }
2676 if (ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2677 Error("malformed block record in AST file");
2678 return Failure;
2679 }
2680 continue;
2681
2682 case OPTIONS_BLOCK_ID:
2683 // If we're reading the first module for this group, check its options
2684 // are compatible with ours. For modules it imports, no further checking
2685 // is required, because we checked them when we built it.
2686 if (Listener && !ImportedBy) {
2687 // Should we allow the configuration of the module file to differ from
2688 // the configuration of the current translation unit in a compatible
2689 // way?
2690 //
2691 // FIXME: Allow this for files explicitly specified with -include-pch.
2692 bool AllowCompatibleConfigurationMismatch =
2693 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2694
2695 ASTReadResult Result =
2696 ReadOptionsBlock(Stream, ClientLoadCapabilities,
2697 AllowCompatibleConfigurationMismatch, *Listener,
2698 SuggestedPredefines);
2699 if (Result == Failure) {
2700 Error("malformed block record in AST file");
2701 return Result;
2702 }
2703
2704 if (DisableValidation ||
2705 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2706 Result = Success;
2707
2708 // If we can't load the module, exit early since we likely
2709 // will rebuild the module anyway. The stream may be in the
2710 // middle of a block.
2711 if (Result != Success)
2712 return Result;
2713 } else if (llvm::Error Err = Stream.SkipBlock()) {
2714 Error(std::move(Err));
2715 return Failure;
2716 }
2717 continue;
2718
2719 default:
2720 if (llvm::Error Err = Stream.SkipBlock()) {
2721 Error(std::move(Err));
2722 return Failure;
2723 }
2724 continue;
2725 }
2726
2727 case llvm::BitstreamEntry::Record:
2728 // The interesting case.
2729 break;
2730 }
2731
2732 // Read and process a record.
2733 Record.clear();
2734 StringRef Blob;
2735 Expected<unsigned> MaybeRecordType =
2736 Stream.readRecord(Entry.ID, Record, &Blob);
2737 if (!MaybeRecordType) {
2738 Error(MaybeRecordType.takeError());
2739 return Failure;
2740 }
2741 switch ((ControlRecordTypes)MaybeRecordType.get()) {
2742 case METADATA: {
2743 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2744 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2745 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2746 : diag::err_pch_version_too_new);
2747 return VersionMismatch;
2748 }
2749
2750 bool hasErrors = Record[7];
2751 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2752 Diag(diag::err_pch_with_compiler_errors);
2753 return HadErrors;
2754 }
2755 if (hasErrors) {
2756 Diags.ErrorOccurred = true;
2757 Diags.UncompilableErrorOccurred = true;
2758 Diags.UnrecoverableErrorOccurred = true;
2759 }
2760
2761 F.RelocatablePCH = Record[4];
2762 // Relative paths in a relocatable PCH are relative to our sysroot.
2763 if (F.RelocatablePCH)
2764 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2765
2766 F.HasTimestamps = Record[5];
2767
2768 F.PCHHasObjectFile = Record[6];
2769
2770 const std::string &CurBranch = getClangFullRepositoryVersion();
2771 StringRef ASTBranch = Blob;
2772 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2773 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2774 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2775 return VersionMismatch;
2776 }
2777 break;
2778 }
2779
2780 case IMPORTS: {
2781 // Validate the AST before processing any imports (otherwise, untangling
2782 // them can be error-prone and expensive). A module will have a name and
2783 // will already have been validated, but this catches the PCH case.
2784 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2785 return Result;
2786
2787 // Load each of the imported PCH files.
2788 unsigned Idx = 0, N = Record.size();
2789 while (Idx < N) {
2790 // Read information about the AST file.
2791 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2792 // The import location will be the local one for now; we will adjust
2793 // all import locations of module imports after the global source
2794 // location info are setup, in ReadAST.
2795 SourceLocation ImportLoc =
2796 ReadUntranslatedSourceLocation(Record[Idx++]);
2797 off_t StoredSize = (off_t)Record[Idx++];
2798 time_t StoredModTime = (time_t)Record[Idx++];
2799 auto FirstSignatureByte = Record.begin() + Idx;
2800 ASTFileSignature StoredSignature = ASTFileSignature::create(
2801 FirstSignatureByte, FirstSignatureByte + ASTFileSignature::size);
2802 Idx += ASTFileSignature::size;
2803
2804 std::string ImportedName = ReadString(Record, Idx);
2805 std::string ImportedFile;
2806
2807 // For prebuilt and explicit modules first consult the file map for
2808 // an override. Note that here we don't search prebuilt module
2809 // directories, only the explicit name to file mappings. Also, we will
2810 // still verify the size/signature making sure it is essentially the
2811 // same file but perhaps in a different location.
2812 if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2813 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2814 ImportedName, /*FileMapOnly*/ true);
2815
2816 if (ImportedFile.empty())
2817 // Use BaseDirectoryAsWritten to ensure we use the same path in the
2818 // ModuleCache as when writing.
2819 ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2820 else
2821 SkipPath(Record, Idx);
2822
2823 // If our client can't cope with us being out of date, we can't cope with
2824 // our dependency being missing.
2825 unsigned Capabilities = ClientLoadCapabilities;
2826 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2827 Capabilities &= ~ARR_Missing;
2828
2829 // Load the AST file.
2830 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2831 Loaded, StoredSize, StoredModTime,
2832 StoredSignature, Capabilities);
2833
2834 // If we diagnosed a problem, produce a backtrace.
2835 if (isDiagnosedResult(Result, Capabilities))
2836 Diag(diag::note_module_file_imported_by)
2837 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2838
2839 switch (Result) {
2840 case Failure: return Failure;
2841 // If we have to ignore the dependency, we'll have to ignore this too.
2842 case Missing:
2843 case OutOfDate: return OutOfDate;
2844 case VersionMismatch: return VersionMismatch;
2845 case ConfigurationMismatch: return ConfigurationMismatch;
2846 case HadErrors: return HadErrors;
2847 case Success: break;
2848 }
2849 }
2850 break;
2851 }
2852
2853 case ORIGINAL_FILE:
2854 F.OriginalSourceFileID = FileID::get(Record[0]);
2855 F.ActualOriginalSourceFileName = std::string(Blob);
2856 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2857 ResolveImportedPath(F, F.OriginalSourceFileName);
2858 break;
2859
2860 case ORIGINAL_FILE_ID:
2861 F.OriginalSourceFileID = FileID::get(Record[0]);
2862 break;
2863
2864 case ORIGINAL_PCH_DIR:
2865 F.OriginalDir = std::string(Blob);
2866 break;
2867
2868 case MODULE_NAME:
2869 F.ModuleName = std::string(Blob);
2870 Diag(diag::remark_module_import)
2871 << F.ModuleName << F.FileName << (ImportedBy ? true : false)
2872 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
2873 if (Listener)
2874 Listener->ReadModuleName(F.ModuleName);
2875
2876 // Validate the AST as soon as we have a name so we can exit early on
2877 // failure.
2878 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2879 return Result;
2880
2881 break;
2882
2883 case MODULE_DIRECTORY: {
2884 // Save the BaseDirectory as written in the PCM for computing the module
2885 // filename for the ModuleCache.
2886 BaseDirectoryAsWritten = Blob;
2887 assert(!F.ModuleName.empty() &&
2888 "MODULE_DIRECTORY found before MODULE_NAME");
2889 // If we've already loaded a module map file covering this module, we may
2890 // have a better path for it (relative to the current build).
2891 Module *M = PP.getHeaderSearchInfo().lookupModule(
2892 F.ModuleName, /*AllowSearch*/ true,
2893 /*AllowExtraModuleMapSearch*/ true);
2894 if (M && M->Directory) {
2895 // If we're implicitly loading a module, the base directory can't
2896 // change between the build and use.
2897 // Don't emit module relocation error if we have -fno-validate-pch
2898 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2899 F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2900 auto BuildDir = PP.getFileManager().getDirectory(Blob);
2901 if (!BuildDir || *BuildDir != M->Directory) {
2902 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2903 Diag(diag::err_imported_module_relocated)
2904 << F.ModuleName << Blob << M->Directory->getName();
2905 return OutOfDate;
2906 }
2907 }
2908 F.BaseDirectory = std::string(M->Directory->getName());
2909 } else {
2910 F.BaseDirectory = std::string(Blob);
2911 }
2912 break;
2913 }
2914
2915 case MODULE_MAP_FILE:
2916 if (ASTReadResult Result =
2917 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2918 return Result;
2919 break;
2920
2921 case INPUT_FILE_OFFSETS:
2922 NumInputs = Record[0];
2923 NumUserInputs = Record[1];
2924 F.InputFileOffsets =
2925 (const llvm::support::unaligned_uint64_t *)Blob.data();
2926 F.InputFilesLoaded.resize(NumInputs);
2927 F.NumUserInputFiles = NumUserInputs;
2928 break;
2929 }
2930 }
2931 }
2932
2933 ASTReader::ASTReadResult
ReadASTBlock(ModuleFile & F,unsigned ClientLoadCapabilities)2934 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2935 BitstreamCursor &Stream = F.Stream;
2936
2937 if (llvm::Error Err = Stream.EnterSubBlock(AST_BLOCK_ID)) {
2938 Error(std::move(Err));
2939 return Failure;
2940 }
2941 F.ASTBlockStartOffset = Stream.GetCurrentBitNo();
2942
2943 // Read all of the records and blocks for the AST file.
2944 RecordData Record;
2945 while (true) {
2946 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
2947 if (!MaybeEntry) {
2948 Error(MaybeEntry.takeError());
2949 return Failure;
2950 }
2951 llvm::BitstreamEntry Entry = MaybeEntry.get();
2952
2953 switch (Entry.Kind) {
2954 case llvm::BitstreamEntry::Error:
2955 Error("error at end of module block in AST file");
2956 return Failure;
2957 case llvm::BitstreamEntry::EndBlock:
2958 // Outside of C++, we do not store a lookup map for the translation unit.
2959 // Instead, mark it as needing a lookup map to be built if this module
2960 // contains any declarations lexically within it (which it always does!).
2961 // This usually has no cost, since we very rarely need the lookup map for
2962 // the translation unit outside C++.
2963 if (ASTContext *Ctx = ContextObj) {
2964 DeclContext *DC = Ctx->getTranslationUnitDecl();
2965 if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2966 DC->setMustBuildLookupTable();
2967 }
2968
2969 return Success;
2970 case llvm::BitstreamEntry::SubBlock:
2971 switch (Entry.ID) {
2972 case DECLTYPES_BLOCK_ID:
2973 // We lazily load the decls block, but we want to set up the
2974 // DeclsCursor cursor to point into it. Clone our current bitcode
2975 // cursor to it, enter the block and read the abbrevs in that block.
2976 // With the main cursor, we just skip over it.
2977 F.DeclsCursor = Stream;
2978 if (llvm::Error Err = Stream.SkipBlock()) {
2979 Error(std::move(Err));
2980 return Failure;
2981 }
2982 if (ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID,
2983 &F.DeclsBlockStartOffset)) {
2984 Error("malformed block record in AST file");
2985 return Failure;
2986 }
2987 break;
2988
2989 case PREPROCESSOR_BLOCK_ID:
2990 F.MacroCursor = Stream;
2991 if (!PP.getExternalSource())
2992 PP.setExternalSource(this);
2993
2994 if (llvm::Error Err = Stream.SkipBlock()) {
2995 Error(std::move(Err));
2996 return Failure;
2997 }
2998 if (ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2999 Error("malformed block record in AST file");
3000 return Failure;
3001 }
3002 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
3003 break;
3004
3005 case PREPROCESSOR_DETAIL_BLOCK_ID:
3006 F.PreprocessorDetailCursor = Stream;
3007
3008 if (llvm::Error Err = Stream.SkipBlock()) {
3009 Error(std::move(Err));
3010 return Failure;
3011 }
3012 if (ReadBlockAbbrevs(F.PreprocessorDetailCursor,
3013 PREPROCESSOR_DETAIL_BLOCK_ID)) {
3014 Error("malformed preprocessor detail record in AST file");
3015 return Failure;
3016 }
3017 F.PreprocessorDetailStartOffset
3018 = F.PreprocessorDetailCursor.GetCurrentBitNo();
3019
3020 if (!PP.getPreprocessingRecord())
3021 PP.createPreprocessingRecord();
3022 if (!PP.getPreprocessingRecord()->getExternalSource())
3023 PP.getPreprocessingRecord()->SetExternalSource(*this);
3024 break;
3025
3026 case SOURCE_MANAGER_BLOCK_ID:
3027 if (ReadSourceManagerBlock(F))
3028 return Failure;
3029 break;
3030
3031 case SUBMODULE_BLOCK_ID:
3032 if (ASTReadResult Result =
3033 ReadSubmoduleBlock(F, ClientLoadCapabilities))
3034 return Result;
3035 break;
3036
3037 case COMMENTS_BLOCK_ID: {
3038 BitstreamCursor C = Stream;
3039
3040 if (llvm::Error Err = Stream.SkipBlock()) {
3041 Error(std::move(Err));
3042 return Failure;
3043 }
3044 if (ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
3045 Error("malformed comments block in AST file");
3046 return Failure;
3047 }
3048 CommentsCursors.push_back(std::make_pair(C, &F));
3049 break;
3050 }
3051
3052 default:
3053 if (llvm::Error Err = Stream.SkipBlock()) {
3054 Error(std::move(Err));
3055 return Failure;
3056 }
3057 break;
3058 }
3059 continue;
3060
3061 case llvm::BitstreamEntry::Record:
3062 // The interesting case.
3063 break;
3064 }
3065
3066 // Read and process a record.
3067 Record.clear();
3068 StringRef Blob;
3069 Expected<unsigned> MaybeRecordType =
3070 Stream.readRecord(Entry.ID, Record, &Blob);
3071 if (!MaybeRecordType) {
3072 Error(MaybeRecordType.takeError());
3073 return Failure;
3074 }
3075 ASTRecordTypes RecordType = (ASTRecordTypes)MaybeRecordType.get();
3076
3077 // If we're not loading an AST context, we don't care about most records.
3078 if (!ContextObj) {
3079 switch (RecordType) {
3080 case IDENTIFIER_TABLE:
3081 case IDENTIFIER_OFFSET:
3082 case INTERESTING_IDENTIFIERS:
3083 case STATISTICS:
3084 case PP_CONDITIONAL_STACK:
3085 case PP_COUNTER_VALUE:
3086 case SOURCE_LOCATION_OFFSETS:
3087 case MODULE_OFFSET_MAP:
3088 case SOURCE_MANAGER_LINE_TABLE:
3089 case SOURCE_LOCATION_PRELOADS:
3090 case PPD_ENTITIES_OFFSETS:
3091 case HEADER_SEARCH_TABLE:
3092 case IMPORTED_MODULES:
3093 case MACRO_OFFSET:
3094 break;
3095 default:
3096 continue;
3097 }
3098 }
3099
3100 switch (RecordType) {
3101 default: // Default behavior: ignore.
3102 break;
3103
3104 case TYPE_OFFSET: {
3105 if (F.LocalNumTypes != 0) {
3106 Error("duplicate TYPE_OFFSET record in AST file");
3107 return Failure;
3108 }
3109 F.TypeOffsets = reinterpret_cast<const UnderalignedInt64 *>(Blob.data());
3110 F.LocalNumTypes = Record[0];
3111 unsigned LocalBaseTypeIndex = Record[1];
3112 F.BaseTypeIndex = getTotalNumTypes();
3113
3114 if (F.LocalNumTypes > 0) {
3115 // Introduce the global -> local mapping for types within this module.
3116 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
3117
3118 // Introduce the local -> global mapping for types within this module.
3119 F.TypeRemap.insertOrReplace(
3120 std::make_pair(LocalBaseTypeIndex,
3121 F.BaseTypeIndex - LocalBaseTypeIndex));
3122
3123 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
3124 }
3125 break;
3126 }
3127
3128 case DECL_OFFSET: {
3129 if (F.LocalNumDecls != 0) {
3130 Error("duplicate DECL_OFFSET record in AST file");
3131 return Failure;
3132 }
3133 F.DeclOffsets = (const DeclOffset *)Blob.data();
3134 F.LocalNumDecls = Record[0];
3135 unsigned LocalBaseDeclID = Record[1];
3136 F.BaseDeclID = getTotalNumDecls();
3137
3138 if (F.LocalNumDecls > 0) {
3139 // Introduce the global -> local mapping for declarations within this
3140 // module.
3141 GlobalDeclMap.insert(
3142 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
3143
3144 // Introduce the local -> global mapping for declarations within this
3145 // module.
3146 F.DeclRemap.insertOrReplace(
3147 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
3148
3149 // Introduce the global -> local mapping for declarations within this
3150 // module.
3151 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
3152
3153 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
3154 }
3155 break;
3156 }
3157
3158 case TU_UPDATE_LEXICAL: {
3159 DeclContext *TU = ContextObj->getTranslationUnitDecl();
3160 LexicalContents Contents(
3161 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
3162 Blob.data()),
3163 static_cast<unsigned int>(Blob.size() / 4));
3164 TULexicalDecls.push_back(std::make_pair(&F, Contents));
3165 TU->setHasExternalLexicalStorage(true);
3166 break;
3167 }
3168
3169 case UPDATE_VISIBLE: {
3170 unsigned Idx = 0;
3171 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
3172 auto *Data = (const unsigned char*)Blob.data();
3173 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
3174 // If we've already loaded the decl, perform the updates when we finish
3175 // loading this block.
3176 if (Decl *D = GetExistingDecl(ID))
3177 PendingUpdateRecords.push_back(
3178 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3179 break;
3180 }
3181
3182 case IDENTIFIER_TABLE:
3183 F.IdentifierTableData = Blob.data();
3184 if (Record[0]) {
3185 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
3186 (const unsigned char *)F.IdentifierTableData + Record[0],
3187 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
3188 (const unsigned char *)F.IdentifierTableData,
3189 ASTIdentifierLookupTrait(*this, F));
3190
3191 PP.getIdentifierTable().setExternalIdentifierLookup(this);
3192 }
3193 break;
3194
3195 case IDENTIFIER_OFFSET: {
3196 if (F.LocalNumIdentifiers != 0) {
3197 Error("duplicate IDENTIFIER_OFFSET record in AST file");
3198 return Failure;
3199 }
3200 F.IdentifierOffsets = (const uint32_t *)Blob.data();
3201 F.LocalNumIdentifiers = Record[0];
3202 unsigned LocalBaseIdentifierID = Record[1];
3203 F.BaseIdentifierID = getTotalNumIdentifiers();
3204
3205 if (F.LocalNumIdentifiers > 0) {
3206 // Introduce the global -> local mapping for identifiers within this
3207 // module.
3208 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
3209 &F));
3210
3211 // Introduce the local -> global mapping for identifiers within this
3212 // module.
3213 F.IdentifierRemap.insertOrReplace(
3214 std::make_pair(LocalBaseIdentifierID,
3215 F.BaseIdentifierID - LocalBaseIdentifierID));
3216
3217 IdentifiersLoaded.resize(IdentifiersLoaded.size()
3218 + F.LocalNumIdentifiers);
3219 }
3220 break;
3221 }
3222
3223 case INTERESTING_IDENTIFIERS:
3224 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
3225 break;
3226
3227 case EAGERLY_DESERIALIZED_DECLS:
3228 // FIXME: Skip reading this record if our ASTConsumer doesn't care
3229 // about "interesting" decls (for instance, if we're building a module).
3230 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3231 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3232 break;
3233
3234 case MODULAR_CODEGEN_DECLS:
3235 // FIXME: Skip reading this record if our ASTConsumer doesn't care about
3236 // them (ie: if we're not codegenerating this module).
3237 if (F.Kind == MK_MainFile ||
3238 getContext().getLangOpts().BuildingPCHWithObjectFile)
3239 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3240 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
3241 break;
3242
3243 case SPECIAL_TYPES:
3244 if (SpecialTypes.empty()) {
3245 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3246 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
3247 break;
3248 }
3249
3250 if (SpecialTypes.size() != Record.size()) {
3251 Error("invalid special-types record");
3252 return Failure;
3253 }
3254
3255 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
3256 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
3257 if (!SpecialTypes[I])
3258 SpecialTypes[I] = ID;
3259 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
3260 // merge step?
3261 }
3262 break;
3263
3264 case STATISTICS:
3265 TotalNumStatements += Record[0];
3266 TotalNumMacros += Record[1];
3267 TotalLexicalDeclContexts += Record[2];
3268 TotalVisibleDeclContexts += Record[3];
3269 break;
3270
3271 case UNUSED_FILESCOPED_DECLS:
3272 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3273 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
3274 break;
3275
3276 case DELEGATING_CTORS:
3277 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3278 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3279 break;
3280
3281 case WEAK_UNDECLARED_IDENTIFIERS:
3282 if (Record.size() % 4 != 0) {
3283 Error("invalid weak identifiers record");
3284 return Failure;
3285 }
3286
3287 // FIXME: Ignore weak undeclared identifiers from non-original PCH
3288 // files. This isn't the way to do it :)
3289 WeakUndeclaredIdentifiers.clear();
3290
3291 // Translate the weak, undeclared identifiers into global IDs.
3292 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3293 WeakUndeclaredIdentifiers.push_back(
3294 getGlobalIdentifierID(F, Record[I++]));
3295 WeakUndeclaredIdentifiers.push_back(
3296 getGlobalIdentifierID(F, Record[I++]));
3297 WeakUndeclaredIdentifiers.push_back(
3298 ReadSourceLocation(F, Record, I).getRawEncoding());
3299 WeakUndeclaredIdentifiers.push_back(Record[I++]);
3300 }
3301 break;
3302
3303 case SELECTOR_OFFSETS: {
3304 F.SelectorOffsets = (const uint32_t *)Blob.data();
3305 F.LocalNumSelectors = Record[0];
3306 unsigned LocalBaseSelectorID = Record[1];
3307 F.BaseSelectorID = getTotalNumSelectors();
3308
3309 if (F.LocalNumSelectors > 0) {
3310 // Introduce the global -> local mapping for selectors within this
3311 // module.
3312 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3313
3314 // Introduce the local -> global mapping for selectors within this
3315 // module.
3316 F.SelectorRemap.insertOrReplace(
3317 std::make_pair(LocalBaseSelectorID,
3318 F.BaseSelectorID - LocalBaseSelectorID));
3319
3320 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3321 }
3322 break;
3323 }
3324
3325 case METHOD_POOL:
3326 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3327 if (Record[0])
3328 F.SelectorLookupTable
3329 = ASTSelectorLookupTable::Create(
3330 F.SelectorLookupTableData + Record[0],
3331 F.SelectorLookupTableData,
3332 ASTSelectorLookupTrait(*this, F));
3333 TotalNumMethodPoolEntries += Record[1];
3334 break;
3335
3336 case REFERENCED_SELECTOR_POOL:
3337 if (!Record.empty()) {
3338 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3339 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3340 Record[Idx++]));
3341 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3342 getRawEncoding());
3343 }
3344 }
3345 break;
3346
3347 case PP_CONDITIONAL_STACK:
3348 if (!Record.empty()) {
3349 unsigned Idx = 0, End = Record.size() - 1;
3350 bool ReachedEOFWhileSkipping = Record[Idx++];
3351 llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3352 if (ReachedEOFWhileSkipping) {
3353 SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3354 SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3355 bool FoundNonSkipPortion = Record[Idx++];
3356 bool FoundElse = Record[Idx++];
3357 SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3358 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3359 FoundElse, ElseLoc);
3360 }
3361 SmallVector<PPConditionalInfo, 4> ConditionalStack;
3362 while (Idx < End) {
3363 auto Loc = ReadSourceLocation(F, Record, Idx);
3364 bool WasSkipping = Record[Idx++];
3365 bool FoundNonSkip = Record[Idx++];
3366 bool FoundElse = Record[Idx++];
3367 ConditionalStack.push_back(
3368 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3369 }
3370 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3371 }
3372 break;
3373
3374 case PP_COUNTER_VALUE:
3375 if (!Record.empty() && Listener)
3376 Listener->ReadCounter(F, Record[0]);
3377 break;
3378
3379 case FILE_SORTED_DECLS:
3380 F.FileSortedDecls = (const DeclID *)Blob.data();
3381 F.NumFileSortedDecls = Record[0];
3382 break;
3383
3384 case SOURCE_LOCATION_OFFSETS: {
3385 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3386 F.LocalNumSLocEntries = Record[0];
3387 unsigned SLocSpaceSize = Record[1];
3388 F.SLocEntryOffsetsBase = Record[2] + F.SourceManagerBlockStartOffset;
3389 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3390 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3391 SLocSpaceSize);
3392 if (!F.SLocEntryBaseID) {
3393 Error("ran out of source locations");
3394 break;
3395 }
3396 // Make our entry in the range map. BaseID is negative and growing, so
3397 // we invert it. Because we invert it, though, we need the other end of
3398 // the range.
3399 unsigned RangeStart =
3400 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3401 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3402 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3403
3404 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3405 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
3406 GlobalSLocOffsetMap.insert(
3407 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3408 - SLocSpaceSize,&F));
3409
3410 // Initialize the remapping table.
3411 // Invalid stays invalid.
3412 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3413 // This module. Base was 2 when being compiled.
3414 F.SLocRemap.insertOrReplace(std::make_pair(2U,
3415 static_cast<int>(F.SLocEntryBaseOffset - 2)));
3416
3417 TotalNumSLocEntries += F.LocalNumSLocEntries;
3418 break;
3419 }
3420
3421 case MODULE_OFFSET_MAP:
3422 F.ModuleOffsetMap = Blob;
3423 break;
3424
3425 case SOURCE_MANAGER_LINE_TABLE:
3426 if (ParseLineTable(F, Record)) {
3427 Error("malformed SOURCE_MANAGER_LINE_TABLE in AST file");
3428 return Failure;
3429 }
3430 break;
3431
3432 case SOURCE_LOCATION_PRELOADS: {
3433 // Need to transform from the local view (1-based IDs) to the global view,
3434 // which is based off F.SLocEntryBaseID.
3435 if (!F.PreloadSLocEntries.empty()) {
3436 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3437 return Failure;
3438 }
3439
3440 F.PreloadSLocEntries.swap(Record);
3441 break;
3442 }
3443
3444 case EXT_VECTOR_DECLS:
3445 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3446 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3447 break;
3448
3449 case VTABLE_USES:
3450 if (Record.size() % 3 != 0) {
3451 Error("Invalid VTABLE_USES record");
3452 return Failure;
3453 }
3454
3455 // Later tables overwrite earlier ones.
3456 // FIXME: Modules will have some trouble with this. This is clearly not
3457 // the right way to do this.
3458 VTableUses.clear();
3459
3460 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3461 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3462 VTableUses.push_back(
3463 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3464 VTableUses.push_back(Record[Idx++]);
3465 }
3466 break;
3467
3468 case PENDING_IMPLICIT_INSTANTIATIONS:
3469 if (PendingInstantiations.size() % 2 != 0) {
3470 Error("Invalid existing PendingInstantiations");
3471 return Failure;
3472 }
3473
3474 if (Record.size() % 2 != 0) {
3475 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3476 return Failure;
3477 }
3478
3479 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3480 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3481 PendingInstantiations.push_back(
3482 ReadSourceLocation(F, Record, I).getRawEncoding());
3483 }
3484 break;
3485
3486 case SEMA_DECL_REFS:
3487 if (Record.size() != 3) {
3488 Error("Invalid SEMA_DECL_REFS block");
3489 return Failure;
3490 }
3491 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3492 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3493 break;
3494
3495 case PPD_ENTITIES_OFFSETS: {
3496 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3497 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
3498 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3499
3500 unsigned LocalBasePreprocessedEntityID = Record[0];
3501
3502 unsigned StartingID;
3503 if (!PP.getPreprocessingRecord())
3504 PP.createPreprocessingRecord();
3505 if (!PP.getPreprocessingRecord()->getExternalSource())
3506 PP.getPreprocessingRecord()->SetExternalSource(*this);
3507 StartingID
3508 = PP.getPreprocessingRecord()
3509 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3510 F.BasePreprocessedEntityID = StartingID;
3511
3512 if (F.NumPreprocessedEntities > 0) {
3513 // Introduce the global -> local mapping for preprocessed entities in
3514 // this module.
3515 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3516
3517 // Introduce the local -> global mapping for preprocessed entities in
3518 // this module.
3519 F.PreprocessedEntityRemap.insertOrReplace(
3520 std::make_pair(LocalBasePreprocessedEntityID,
3521 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3522 }
3523
3524 break;
3525 }
3526
3527 case PPD_SKIPPED_RANGES: {
3528 F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3529 assert(Blob.size() % sizeof(PPSkippedRange) == 0);
3530 F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3531
3532 if (!PP.getPreprocessingRecord())
3533 PP.createPreprocessingRecord();
3534 if (!PP.getPreprocessingRecord()->getExternalSource())
3535 PP.getPreprocessingRecord()->SetExternalSource(*this);
3536 F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3537 ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3538
3539 if (F.NumPreprocessedSkippedRanges > 0)
3540 GlobalSkippedRangeMap.insert(
3541 std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3542 break;
3543 }
3544
3545 case DECL_UPDATE_OFFSETS:
3546 if (Record.size() % 2 != 0) {
3547 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3548 return Failure;
3549 }
3550 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3551 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3552 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3553
3554 // If we've already loaded the decl, perform the updates when we finish
3555 // loading this block.
3556 if (Decl *D = GetExistingDecl(ID))
3557 PendingUpdateRecords.push_back(
3558 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3559 }
3560 break;
3561
3562 case OBJC_CATEGORIES_MAP:
3563 if (F.LocalNumObjCCategoriesInMap != 0) {
3564 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3565 return Failure;
3566 }
3567
3568 F.LocalNumObjCCategoriesInMap = Record[0];
3569 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3570 break;
3571
3572 case OBJC_CATEGORIES:
3573 F.ObjCCategories.swap(Record);
3574 break;
3575
3576 case CUDA_SPECIAL_DECL_REFS:
3577 // Later tables overwrite earlier ones.
3578 // FIXME: Modules will have trouble with this.
3579 CUDASpecialDeclRefs.clear();
3580 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3581 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3582 break;
3583
3584 case HEADER_SEARCH_TABLE:
3585 F.HeaderFileInfoTableData = Blob.data();
3586 F.LocalNumHeaderFileInfos = Record[1];
3587 if (Record[0]) {
3588 F.HeaderFileInfoTable
3589 = HeaderFileInfoLookupTable::Create(
3590 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3591 (const unsigned char *)F.HeaderFileInfoTableData,
3592 HeaderFileInfoTrait(*this, F,
3593 &PP.getHeaderSearchInfo(),
3594 Blob.data() + Record[2]));
3595
3596 PP.getHeaderSearchInfo().SetExternalSource(this);
3597 if (!PP.getHeaderSearchInfo().getExternalLookup())
3598 PP.getHeaderSearchInfo().SetExternalLookup(this);
3599 }
3600 break;
3601
3602 case FP_PRAGMA_OPTIONS:
3603 // Later tables overwrite earlier ones.
3604 FPPragmaOptions.swap(Record);
3605 break;
3606
3607 case OPENCL_EXTENSIONS:
3608 for (unsigned I = 0, E = Record.size(); I != E; ) {
3609 auto Name = ReadString(Record, I);
3610 auto &Opt = OpenCLExtensions.OptMap[Name];
3611 Opt.Supported = Record[I++] != 0;
3612 Opt.Enabled = Record[I++] != 0;
3613 Opt.Avail = Record[I++];
3614 Opt.Core = Record[I++];
3615 }
3616 break;
3617
3618 case OPENCL_EXTENSION_TYPES:
3619 for (unsigned I = 0, E = Record.size(); I != E;) {
3620 auto TypeID = static_cast<::TypeID>(Record[I++]);
3621 auto *Type = GetType(TypeID).getTypePtr();
3622 auto NumExt = static_cast<unsigned>(Record[I++]);
3623 for (unsigned II = 0; II != NumExt; ++II) {
3624 auto Ext = ReadString(Record, I);
3625 OpenCLTypeExtMap[Type].insert(Ext);
3626 }
3627 }
3628 break;
3629
3630 case OPENCL_EXTENSION_DECLS:
3631 for (unsigned I = 0, E = Record.size(); I != E;) {
3632 auto DeclID = static_cast<::DeclID>(Record[I++]);
3633 auto *Decl = GetDecl(DeclID);
3634 auto NumExt = static_cast<unsigned>(Record[I++]);
3635 for (unsigned II = 0; II != NumExt; ++II) {
3636 auto Ext = ReadString(Record, I);
3637 OpenCLDeclExtMap[Decl].insert(Ext);
3638 }
3639 }
3640 break;
3641
3642 case TENTATIVE_DEFINITIONS:
3643 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3644 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3645 break;
3646
3647 case KNOWN_NAMESPACES:
3648 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3649 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3650 break;
3651
3652 case UNDEFINED_BUT_USED:
3653 if (UndefinedButUsed.size() % 2 != 0) {
3654 Error("Invalid existing UndefinedButUsed");
3655 return Failure;
3656 }
3657
3658 if (Record.size() % 2 != 0) {
3659 Error("invalid undefined-but-used record");
3660 return Failure;
3661 }
3662 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3663 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3664 UndefinedButUsed.push_back(
3665 ReadSourceLocation(F, Record, I).getRawEncoding());
3666 }
3667 break;
3668
3669 case DELETE_EXPRS_TO_ANALYZE:
3670 for (unsigned I = 0, N = Record.size(); I != N;) {
3671 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3672 const uint64_t Count = Record[I++];
3673 DelayedDeleteExprs.push_back(Count);
3674 for (uint64_t C = 0; C < Count; ++C) {
3675 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3676 bool IsArrayForm = Record[I++] == 1;
3677 DelayedDeleteExprs.push_back(IsArrayForm);
3678 }
3679 }
3680 break;
3681
3682 case IMPORTED_MODULES:
3683 if (!F.isModule()) {
3684 // If we aren't loading a module (which has its own exports), make
3685 // all of the imported modules visible.
3686 // FIXME: Deal with macros-only imports.
3687 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3688 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3689 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3690 if (GlobalID) {
3691 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3692 if (DeserializationListener)
3693 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3694 }
3695 }
3696 }
3697 break;
3698
3699 case MACRO_OFFSET: {
3700 if (F.LocalNumMacros != 0) {
3701 Error("duplicate MACRO_OFFSET record in AST file");
3702 return Failure;
3703 }
3704 F.MacroOffsets = (const uint32_t *)Blob.data();
3705 F.LocalNumMacros = Record[0];
3706 unsigned LocalBaseMacroID = Record[1];
3707 F.MacroOffsetsBase = Record[2] + F.ASTBlockStartOffset;
3708 F.BaseMacroID = getTotalNumMacros();
3709
3710 if (F.LocalNumMacros > 0) {
3711 // Introduce the global -> local mapping for macros within this module.
3712 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3713
3714 // Introduce the local -> global mapping for macros within this module.
3715 F.MacroRemap.insertOrReplace(
3716 std::make_pair(LocalBaseMacroID,
3717 F.BaseMacroID - LocalBaseMacroID));
3718
3719 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3720 }
3721 break;
3722 }
3723
3724 case LATE_PARSED_TEMPLATE:
3725 LateParsedTemplates.append(Record.begin(), Record.end());
3726 break;
3727
3728 case OPTIMIZE_PRAGMA_OPTIONS:
3729 if (Record.size() != 1) {
3730 Error("invalid pragma optimize record");
3731 return Failure;
3732 }
3733 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3734 break;
3735
3736 case MSSTRUCT_PRAGMA_OPTIONS:
3737 if (Record.size() != 1) {
3738 Error("invalid pragma ms_struct record");
3739 return Failure;
3740 }
3741 PragmaMSStructState = Record[0];
3742 break;
3743
3744 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3745 if (Record.size() != 2) {
3746 Error("invalid pragma ms_struct record");
3747 return Failure;
3748 }
3749 PragmaMSPointersToMembersState = Record[0];
3750 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3751 break;
3752
3753 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3754 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3755 UnusedLocalTypedefNameCandidates.push_back(
3756 getGlobalDeclID(F, Record[I]));
3757 break;
3758
3759 case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3760 if (Record.size() != 1) {
3761 Error("invalid cuda pragma options record");
3762 return Failure;
3763 }
3764 ForceCUDAHostDeviceDepth = Record[0];
3765 break;
3766
3767 case PACK_PRAGMA_OPTIONS: {
3768 if (Record.size() < 3) {
3769 Error("invalid pragma pack record");
3770 return Failure;
3771 }
3772 PragmaPackCurrentValue = Record[0];
3773 PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3774 unsigned NumStackEntries = Record[2];
3775 unsigned Idx = 3;
3776 // Reset the stack when importing a new module.
3777 PragmaPackStack.clear();
3778 for (unsigned I = 0; I < NumStackEntries; ++I) {
3779 PragmaPackStackEntry Entry;
3780 Entry.Value = Record[Idx++];
3781 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3782 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3783 PragmaPackStrings.push_back(ReadString(Record, Idx));
3784 Entry.SlotLabel = PragmaPackStrings.back();
3785 PragmaPackStack.push_back(Entry);
3786 }
3787 break;
3788 }
3789
3790 case FLOAT_CONTROL_PRAGMA_OPTIONS: {
3791 if (Record.size() < 3) {
3792 Error("invalid pragma pack record");
3793 return Failure;
3794 }
3795 FpPragmaCurrentValue = Record[0];
3796 FpPragmaCurrentLocation = ReadSourceLocation(F, Record[1]);
3797 unsigned NumStackEntries = Record[2];
3798 unsigned Idx = 3;
3799 // Reset the stack when importing a new module.
3800 FpPragmaStack.clear();
3801 for (unsigned I = 0; I < NumStackEntries; ++I) {
3802 FpPragmaStackEntry Entry;
3803 Entry.Value = Record[Idx++];
3804 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3805 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3806 FpPragmaStrings.push_back(ReadString(Record, Idx));
3807 Entry.SlotLabel = FpPragmaStrings.back();
3808 FpPragmaStack.push_back(Entry);
3809 }
3810 break;
3811 }
3812
3813 case DECLS_TO_CHECK_FOR_DEFERRED_DIAGS:
3814 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3815 DeclsToCheckForDeferredDiags.push_back(getGlobalDeclID(F, Record[I]));
3816 break;
3817 }
3818 }
3819 }
3820
ReadModuleOffsetMap(ModuleFile & F) const3821 void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3822 assert(!F.ModuleOffsetMap.empty() && "no module offset map to read");
3823
3824 // Additional remapping information.
3825 const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3826 const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3827 F.ModuleOffsetMap = StringRef();
3828
3829 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3830 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3831 F.SLocRemap.insert(std::make_pair(0U, 0));
3832 F.SLocRemap.insert(std::make_pair(2U, 1));
3833 }
3834
3835 // Continuous range maps we may be updating in our module.
3836 using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3837 RemapBuilder SLocRemap(F.SLocRemap);
3838 RemapBuilder IdentifierRemap(F.IdentifierRemap);
3839 RemapBuilder MacroRemap(F.MacroRemap);
3840 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3841 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3842 RemapBuilder SelectorRemap(F.SelectorRemap);
3843 RemapBuilder DeclRemap(F.DeclRemap);
3844 RemapBuilder TypeRemap(F.TypeRemap);
3845
3846 while (Data < DataEnd) {
3847 // FIXME: Looking up dependency modules by filename is horrible. Let's
3848 // start fixing this with prebuilt, explicit and implicit modules and see
3849 // how it goes...
3850 using namespace llvm::support;
3851 ModuleKind Kind = static_cast<ModuleKind>(
3852 endian::readNext<uint8_t, little, unaligned>(Data));
3853 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3854 StringRef Name = StringRef((const char*)Data, Len);
3855 Data += Len;
3856 ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule ||
3857 Kind == MK_ImplicitModule
3858 ? ModuleMgr.lookupByModuleName(Name)
3859 : ModuleMgr.lookupByFileName(Name));
3860 if (!OM) {
3861 std::string Msg =
3862 "SourceLocation remap refers to unknown module, cannot find ";
3863 Msg.append(std::string(Name));
3864 Error(Msg);
3865 return;
3866 }
3867
3868 uint32_t SLocOffset =
3869 endian::readNext<uint32_t, little, unaligned>(Data);
3870 uint32_t IdentifierIDOffset =
3871 endian::readNext<uint32_t, little, unaligned>(Data);
3872 uint32_t MacroIDOffset =
3873 endian::readNext<uint32_t, little, unaligned>(Data);
3874 uint32_t PreprocessedEntityIDOffset =
3875 endian::readNext<uint32_t, little, unaligned>(Data);
3876 uint32_t SubmoduleIDOffset =
3877 endian::readNext<uint32_t, little, unaligned>(Data);
3878 uint32_t SelectorIDOffset =
3879 endian::readNext<uint32_t, little, unaligned>(Data);
3880 uint32_t DeclIDOffset =
3881 endian::readNext<uint32_t, little, unaligned>(Data);
3882 uint32_t TypeIndexOffset =
3883 endian::readNext<uint32_t, little, unaligned>(Data);
3884
3885 uint32_t None = std::numeric_limits<uint32_t>::max();
3886
3887 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3888 RemapBuilder &Remap) {
3889 if (Offset != None)
3890 Remap.insert(std::make_pair(Offset,
3891 static_cast<int>(BaseOffset - Offset)));
3892 };
3893 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3894 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3895 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3896 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3897 PreprocessedEntityRemap);
3898 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3899 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3900 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3901 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3902
3903 // Global -> local mappings.
3904 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3905 }
3906 }
3907
3908 ASTReader::ASTReadResult
ReadModuleMapFileBlock(RecordData & Record,ModuleFile & F,const ModuleFile * ImportedBy,unsigned ClientLoadCapabilities)3909 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3910 const ModuleFile *ImportedBy,
3911 unsigned ClientLoadCapabilities) {
3912 unsigned Idx = 0;
3913 F.ModuleMapPath = ReadPath(F, Record, Idx);
3914
3915 // Try to resolve ModuleName in the current header search context and
3916 // verify that it is found in the same module map file as we saved. If the
3917 // top-level AST file is a main file, skip this check because there is no
3918 // usable header search context.
3919 assert(!F.ModuleName.empty() &&
3920 "MODULE_NAME should come before MODULE_MAP_FILE");
3921 if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3922 // An implicitly-loaded module file should have its module listed in some
3923 // module map file that we've already loaded.
3924 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3925 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3926 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3927 // Don't emit module relocation error if we have -fno-validate-pch
3928 if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3929 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3930 if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3931 // This module was defined by an imported (explicit) module.
3932 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3933 << ASTFE->getName();
3934 } else {
3935 // This module was built with a different module map.
3936 Diag(diag::err_imported_module_not_found)
3937 << F.ModuleName << F.FileName
3938 << (ImportedBy ? ImportedBy->FileName : "") << F.ModuleMapPath
3939 << !ImportedBy;
3940 // In case it was imported by a PCH, there's a chance the user is
3941 // just missing to include the search path to the directory containing
3942 // the modulemap.
3943 if (ImportedBy && ImportedBy->Kind == MK_PCH)
3944 Diag(diag::note_imported_by_pch_module_not_found)
3945 << llvm::sys::path::parent_path(F.ModuleMapPath);
3946 }
3947 }
3948 return OutOfDate;
3949 }
3950
3951 assert(M->Name == F.ModuleName && "found module with different name");
3952
3953 // Check the primary module map file.
3954 auto StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3955 if (!StoredModMap || *StoredModMap != ModMap) {
3956 assert(ModMap && "found module is missing module map file");
3957 assert((ImportedBy || F.Kind == MK_ImplicitModule) &&
3958 "top-level import should be verified");
3959 bool NotImported = F.Kind == MK_ImplicitModule && !ImportedBy;
3960 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3961 Diag(diag::err_imported_module_modmap_changed)
3962 << F.ModuleName << (NotImported ? F.FileName : ImportedBy->FileName)
3963 << ModMap->getName() << F.ModuleMapPath << NotImported;
3964 return OutOfDate;
3965 }
3966
3967 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3968 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3969 // FIXME: we should use input files rather than storing names.
3970 std::string Filename = ReadPath(F, Record, Idx);
3971 auto F = FileMgr.getFile(Filename, false, false);
3972 if (!F) {
3973 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3974 Error("could not find file '" + Filename +"' referenced by AST file");
3975 return OutOfDate;
3976 }
3977 AdditionalStoredMaps.insert(*F);
3978 }
3979
3980 // Check any additional module map files (e.g. module.private.modulemap)
3981 // that are not in the pcm.
3982 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3983 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3984 // Remove files that match
3985 // Note: SmallPtrSet::erase is really remove
3986 if (!AdditionalStoredMaps.erase(ModMap)) {
3987 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3988 Diag(diag::err_module_different_modmap)
3989 << F.ModuleName << /*new*/0 << ModMap->getName();
3990 return OutOfDate;
3991 }
3992 }
3993 }
3994
3995 // Check any additional module map files that are in the pcm, but not
3996 // found in header search. Cases that match are already removed.
3997 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3998 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3999 Diag(diag::err_module_different_modmap)
4000 << F.ModuleName << /*not new*/1 << ModMap->getName();
4001 return OutOfDate;
4002 }
4003 }
4004
4005 if (Listener)
4006 Listener->ReadModuleMapFile(F.ModuleMapPath);
4007 return Success;
4008 }
4009
4010 /// Move the given method to the back of the global list of methods.
moveMethodToBackOfGlobalList(Sema & S,ObjCMethodDecl * Method)4011 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
4012 // Find the entry for this selector in the method pool.
4013 Sema::GlobalMethodPool::iterator Known
4014 = S.MethodPool.find(Method->getSelector());
4015 if (Known == S.MethodPool.end())
4016 return;
4017
4018 // Retrieve the appropriate method list.
4019 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
4020 : Known->second.second;
4021 bool Found = false;
4022 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
4023 if (!Found) {
4024 if (List->getMethod() == Method) {
4025 Found = true;
4026 } else {
4027 // Keep searching.
4028 continue;
4029 }
4030 }
4031
4032 if (List->getNext())
4033 List->setMethod(List->getNext()->getMethod());
4034 else
4035 List->setMethod(Method);
4036 }
4037 }
4038
makeNamesVisible(const HiddenNames & Names,Module * Owner)4039 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
4040 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
4041 for (Decl *D : Names) {
4042 bool wasHidden = !D->isUnconditionallyVisible();
4043 D->setVisibleDespiteOwningModule();
4044
4045 if (wasHidden && SemaObj) {
4046 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
4047 moveMethodToBackOfGlobalList(*SemaObj, Method);
4048 }
4049 }
4050 }
4051 }
4052
makeModuleVisible(Module * Mod,Module::NameVisibilityKind NameVisibility,SourceLocation ImportLoc)4053 void ASTReader::makeModuleVisible(Module *Mod,
4054 Module::NameVisibilityKind NameVisibility,
4055 SourceLocation ImportLoc) {
4056 llvm::SmallPtrSet<Module *, 4> Visited;
4057 SmallVector<Module *, 4> Stack;
4058 Stack.push_back(Mod);
4059 while (!Stack.empty()) {
4060 Mod = Stack.pop_back_val();
4061
4062 if (NameVisibility <= Mod->NameVisibility) {
4063 // This module already has this level of visibility (or greater), so
4064 // there is nothing more to do.
4065 continue;
4066 }
4067
4068 if (Mod->isUnimportable()) {
4069 // Modules that aren't importable cannot be made visible.
4070 continue;
4071 }
4072
4073 // Update the module's name visibility.
4074 Mod->NameVisibility = NameVisibility;
4075
4076 // If we've already deserialized any names from this module,
4077 // mark them as visible.
4078 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
4079 if (Hidden != HiddenNamesMap.end()) {
4080 auto HiddenNames = std::move(*Hidden);
4081 HiddenNamesMap.erase(Hidden);
4082 makeNamesVisible(HiddenNames.second, HiddenNames.first);
4083 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
4084 "making names visible added hidden names");
4085 }
4086
4087 // Push any exported modules onto the stack to be marked as visible.
4088 SmallVector<Module *, 16> Exports;
4089 Mod->getExportedModules(Exports);
4090 for (SmallVectorImpl<Module *>::iterator
4091 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
4092 Module *Exported = *I;
4093 if (Visited.insert(Exported).second)
4094 Stack.push_back(Exported);
4095 }
4096 }
4097 }
4098
4099 /// We've merged the definition \p MergedDef into the existing definition
4100 /// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
4101 /// visible.
mergeDefinitionVisibility(NamedDecl * Def,NamedDecl * MergedDef)4102 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
4103 NamedDecl *MergedDef) {
4104 if (!Def->isUnconditionallyVisible()) {
4105 // If MergedDef is visible or becomes visible, make the definition visible.
4106 if (MergedDef->isUnconditionallyVisible())
4107 Def->setVisibleDespiteOwningModule();
4108 else {
4109 getContext().mergeDefinitionIntoModule(
4110 Def, MergedDef->getImportedOwningModule(),
4111 /*NotifyListeners*/ false);
4112 PendingMergedDefinitionsToDeduplicate.insert(Def);
4113 }
4114 }
4115 }
4116
loadGlobalIndex()4117 bool ASTReader::loadGlobalIndex() {
4118 if (GlobalIndex)
4119 return false;
4120
4121 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
4122 !PP.getLangOpts().Modules)
4123 return true;
4124
4125 // Try to load the global index.
4126 TriedLoadingGlobalIndex = true;
4127 StringRef ModuleCachePath
4128 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
4129 std::pair<GlobalModuleIndex *, llvm::Error> Result =
4130 GlobalModuleIndex::readIndex(ModuleCachePath);
4131 if (llvm::Error Err = std::move(Result.second)) {
4132 assert(!Result.first);
4133 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
4134 return true;
4135 }
4136
4137 GlobalIndex.reset(Result.first);
4138 ModuleMgr.setGlobalIndex(GlobalIndex.get());
4139 return false;
4140 }
4141
isGlobalIndexUnavailable() const4142 bool ASTReader::isGlobalIndexUnavailable() const {
4143 return PP.getLangOpts().Modules && UseGlobalIndex &&
4144 !hasGlobalIndex() && TriedLoadingGlobalIndex;
4145 }
4146
updateModuleTimestamp(ModuleFile & MF)4147 static void updateModuleTimestamp(ModuleFile &MF) {
4148 // Overwrite the timestamp file contents so that file's mtime changes.
4149 std::string TimestampFilename = MF.getTimestampFilename();
4150 std::error_code EC;
4151 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::OF_Text);
4152 if (EC)
4153 return;
4154 OS << "Timestamp file\n";
4155 OS.close();
4156 OS.clear_error(); // Avoid triggering a fatal error.
4157 }
4158
4159 /// Given a cursor at the start of an AST file, scan ahead and drop the
4160 /// cursor into the start of the given block ID, returning false on success and
4161 /// true on failure.
SkipCursorToBlock(BitstreamCursor & Cursor,unsigned BlockID)4162 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
4163 while (true) {
4164 Expected<llvm::BitstreamEntry> MaybeEntry = Cursor.advance();
4165 if (!MaybeEntry) {
4166 // FIXME this drops errors on the floor.
4167 consumeError(MaybeEntry.takeError());
4168 return true;
4169 }
4170 llvm::BitstreamEntry Entry = MaybeEntry.get();
4171
4172 switch (Entry.Kind) {
4173 case llvm::BitstreamEntry::Error:
4174 case llvm::BitstreamEntry::EndBlock:
4175 return true;
4176
4177 case llvm::BitstreamEntry::Record:
4178 // Ignore top-level records.
4179 if (Expected<unsigned> Skipped = Cursor.skipRecord(Entry.ID))
4180 break;
4181 else {
4182 // FIXME this drops errors on the floor.
4183 consumeError(Skipped.takeError());
4184 return true;
4185 }
4186
4187 case llvm::BitstreamEntry::SubBlock:
4188 if (Entry.ID == BlockID) {
4189 if (llvm::Error Err = Cursor.EnterSubBlock(BlockID)) {
4190 // FIXME this drops the error on the floor.
4191 consumeError(std::move(Err));
4192 return true;
4193 }
4194 // Found it!
4195 return false;
4196 }
4197
4198 if (llvm::Error Err = Cursor.SkipBlock()) {
4199 // FIXME this drops the error on the floor.
4200 consumeError(std::move(Err));
4201 return true;
4202 }
4203 }
4204 }
4205 }
4206
ReadAST(StringRef FileName,ModuleKind Type,SourceLocation ImportLoc,unsigned ClientLoadCapabilities,SmallVectorImpl<ImportedSubmodule> * Imported)4207 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
4208 ModuleKind Type,
4209 SourceLocation ImportLoc,
4210 unsigned ClientLoadCapabilities,
4211 SmallVectorImpl<ImportedSubmodule> *Imported) {
4212 llvm::SaveAndRestore<SourceLocation>
4213 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
4214
4215 // Defer any pending actions until we get to the end of reading the AST file.
4216 Deserializing AnASTFile(this);
4217
4218 // Bump the generation number.
4219 unsigned PreviousGeneration = 0;
4220 if (ContextObj)
4221 PreviousGeneration = incrementGeneration(*ContextObj);
4222
4223 unsigned NumModules = ModuleMgr.size();
4224 auto removeModulesAndReturn = [&](ASTReadResult ReadResult) {
4225 assert(ReadResult && "expected to return error");
4226 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules,
4227 PP.getLangOpts().Modules
4228 ? &PP.getHeaderSearchInfo().getModuleMap()
4229 : nullptr);
4230
4231 // If we find that any modules are unusable, the global index is going
4232 // to be out-of-date. Just remove it.
4233 GlobalIndex.reset();
4234 ModuleMgr.setGlobalIndex(nullptr);
4235 return ReadResult;
4236 };
4237
4238 SmallVector<ImportedModule, 4> Loaded;
4239 switch (ASTReadResult ReadResult =
4240 ReadASTCore(FileName, Type, ImportLoc,
4241 /*ImportedBy=*/nullptr, Loaded, 0, 0,
4242 ASTFileSignature(), ClientLoadCapabilities)) {
4243 case Failure:
4244 case Missing:
4245 case OutOfDate:
4246 case VersionMismatch:
4247 case ConfigurationMismatch:
4248 case HadErrors:
4249 return removeModulesAndReturn(ReadResult);
4250 case Success:
4251 break;
4252 }
4253
4254 // Here comes stuff that we only do once the entire chain is loaded.
4255
4256 // Load the AST blocks of all of the modules that we loaded. We can still
4257 // hit errors parsing the ASTs at this point.
4258 for (ImportedModule &M : Loaded) {
4259 ModuleFile &F = *M.Mod;
4260
4261 // Read the AST block.
4262 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
4263 return removeModulesAndReturn(Result);
4264
4265 // The AST block should always have a definition for the main module.
4266 if (F.isModule() && !F.DidReadTopLevelSubmodule) {
4267 Error(diag::err_module_file_missing_top_level_submodule, F.FileName);
4268 return removeModulesAndReturn(Failure);
4269 }
4270
4271 // Read the extension blocks.
4272 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
4273 if (ASTReadResult Result = ReadExtensionBlock(F))
4274 return removeModulesAndReturn(Result);
4275 }
4276
4277 // Once read, set the ModuleFile bit base offset and update the size in
4278 // bits of all files we've seen.
4279 F.GlobalBitOffset = TotalModulesSizeInBits;
4280 TotalModulesSizeInBits += F.SizeInBits;
4281 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
4282 }
4283
4284 // Preload source locations and interesting indentifiers.
4285 for (ImportedModule &M : Loaded) {
4286 ModuleFile &F = *M.Mod;
4287
4288 // Preload SLocEntries.
4289 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
4290 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
4291 // Load it through the SourceManager and don't call ReadSLocEntry()
4292 // directly because the entry may have already been loaded in which case
4293 // calling ReadSLocEntry() directly would trigger an assertion in
4294 // SourceManager.
4295 SourceMgr.getLoadedSLocEntryByID(Index);
4296 }
4297
4298 // Map the original source file ID into the ID space of the current
4299 // compilation.
4300 if (F.OriginalSourceFileID.isValid()) {
4301 F.OriginalSourceFileID = FileID::get(
4302 F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
4303 }
4304
4305 // Preload all the pending interesting identifiers by marking them out of
4306 // date.
4307 for (auto Offset : F.PreloadIdentifierOffsets) {
4308 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
4309 F.IdentifierTableData + Offset);
4310
4311 ASTIdentifierLookupTrait Trait(*this, F);
4312 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
4313 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
4314 auto &II = PP.getIdentifierTable().getOwn(Key);
4315 II.setOutOfDate(true);
4316
4317 // Mark this identifier as being from an AST file so that we can track
4318 // whether we need to serialize it.
4319 markIdentifierFromAST(*this, II);
4320
4321 // Associate the ID with the identifier so that the writer can reuse it.
4322 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
4323 SetIdentifierInfo(ID, &II);
4324 }
4325 }
4326
4327 // Setup the import locations and notify the module manager that we've
4328 // committed to these module files.
4329 for (ImportedModule &M : Loaded) {
4330 ModuleFile &F = *M.Mod;
4331
4332 ModuleMgr.moduleFileAccepted(&F);
4333
4334 // Set the import location.
4335 F.DirectImportLoc = ImportLoc;
4336 // FIXME: We assume that locations from PCH / preamble do not need
4337 // any translation.
4338 if (!M.ImportedBy)
4339 F.ImportLoc = M.ImportLoc;
4340 else
4341 F.ImportLoc = TranslateSourceLocation(*M.ImportedBy, M.ImportLoc);
4342 }
4343
4344 if (!PP.getLangOpts().CPlusPlus ||
4345 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
4346 Type != MK_PrebuiltModule)) {
4347 // Mark all of the identifiers in the identifier table as being out of date,
4348 // so that various accessors know to check the loaded modules when the
4349 // identifier is used.
4350 //
4351 // For C++ modules, we don't need information on many identifiers (just
4352 // those that provide macros or are poisoned), so we mark all of
4353 // the interesting ones via PreloadIdentifierOffsets.
4354 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4355 IdEnd = PP.getIdentifierTable().end();
4356 Id != IdEnd; ++Id)
4357 Id->second->setOutOfDate(true);
4358 }
4359 // Mark selectors as out of date.
4360 for (auto Sel : SelectorGeneration)
4361 SelectorOutOfDate[Sel.first] = true;
4362
4363 // Resolve any unresolved module exports.
4364 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4365 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4366 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4367 Module *ResolvedMod = getSubmodule(GlobalID);
4368
4369 switch (Unresolved.Kind) {
4370 case UnresolvedModuleRef::Conflict:
4371 if (ResolvedMod) {
4372 Module::Conflict Conflict;
4373 Conflict.Other = ResolvedMod;
4374 Conflict.Message = Unresolved.String.str();
4375 Unresolved.Mod->Conflicts.push_back(Conflict);
4376 }
4377 continue;
4378
4379 case UnresolvedModuleRef::Import:
4380 if (ResolvedMod)
4381 Unresolved.Mod->Imports.insert(ResolvedMod);
4382 continue;
4383
4384 case UnresolvedModuleRef::Export:
4385 if (ResolvedMod || Unresolved.IsWildcard)
4386 Unresolved.Mod->Exports.push_back(
4387 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4388 continue;
4389 }
4390 }
4391 UnresolvedModuleRefs.clear();
4392
4393 if (Imported)
4394 Imported->append(ImportedModules.begin(),
4395 ImportedModules.end());
4396
4397 // FIXME: How do we load the 'use'd modules? They may not be submodules.
4398 // Might be unnecessary as use declarations are only used to build the
4399 // module itself.
4400
4401 if (ContextObj)
4402 InitializeContext();
4403
4404 if (SemaObj)
4405 UpdateSema();
4406
4407 if (DeserializationListener)
4408 DeserializationListener->ReaderInitialized(this);
4409
4410 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4411 if (PrimaryModule.OriginalSourceFileID.isValid()) {
4412 // If this AST file is a precompiled preamble, then set the
4413 // preamble file ID of the source manager to the file source file
4414 // from which the preamble was built.
4415 if (Type == MK_Preamble) {
4416 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4417 } else if (Type == MK_MainFile) {
4418 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4419 }
4420 }
4421
4422 // For any Objective-C class definitions we have already loaded, make sure
4423 // that we load any additional categories.
4424 if (ContextObj) {
4425 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4426 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4427 ObjCClassesLoaded[I],
4428 PreviousGeneration);
4429 }
4430 }
4431
4432 if (PP.getHeaderSearchInfo()
4433 .getHeaderSearchOpts()
4434 .ModulesValidateOncePerBuildSession) {
4435 // Now we are certain that the module and all modules it depends on are
4436 // up to date. Create or update timestamp files for modules that are
4437 // located in the module cache (not for PCH files that could be anywhere
4438 // in the filesystem).
4439 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4440 ImportedModule &M = Loaded[I];
4441 if (M.Mod->Kind == MK_ImplicitModule) {
4442 updateModuleTimestamp(*M.Mod);
4443 }
4444 }
4445 }
4446
4447 return Success;
4448 }
4449
4450 static ASTFileSignature readASTFileSignature(StringRef PCH);
4451
4452 /// Whether \p Stream doesn't start with the AST/PCH file magic number 'CPCH'.
doesntStartWithASTFileMagic(BitstreamCursor & Stream)4453 static llvm::Error doesntStartWithASTFileMagic(BitstreamCursor &Stream) {
4454 // FIXME checking magic headers is done in other places such as
4455 // SerializedDiagnosticReader and GlobalModuleIndex, but error handling isn't
4456 // always done the same. Unify it all with a helper.
4457 if (!Stream.canSkipToPos(4))
4458 return llvm::createStringError(std::errc::illegal_byte_sequence,
4459 "file too small to contain AST file magic");
4460 for (unsigned C : {'C', 'P', 'C', 'H'})
4461 if (Expected<llvm::SimpleBitstreamCursor::word_t> Res = Stream.Read(8)) {
4462 if (Res.get() != C)
4463 return llvm::createStringError(
4464 std::errc::illegal_byte_sequence,
4465 "file doesn't start with AST file magic");
4466 } else
4467 return Res.takeError();
4468 return llvm::Error::success();
4469 }
4470
moduleKindForDiagnostic(ModuleKind Kind)4471 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4472 switch (Kind) {
4473 case MK_PCH:
4474 return 0; // PCH
4475 case MK_ImplicitModule:
4476 case MK_ExplicitModule:
4477 case MK_PrebuiltModule:
4478 return 1; // module
4479 case MK_MainFile:
4480 case MK_Preamble:
4481 return 2; // main source file
4482 }
4483 llvm_unreachable("unknown module kind");
4484 }
4485
4486 ASTReader::ASTReadResult
ReadASTCore(StringRef FileName,ModuleKind Type,SourceLocation ImportLoc,ModuleFile * ImportedBy,SmallVectorImpl<ImportedModule> & Loaded,off_t ExpectedSize,time_t ExpectedModTime,ASTFileSignature ExpectedSignature,unsigned ClientLoadCapabilities)4487 ASTReader::ReadASTCore(StringRef FileName,
4488 ModuleKind Type,
4489 SourceLocation ImportLoc,
4490 ModuleFile *ImportedBy,
4491 SmallVectorImpl<ImportedModule> &Loaded,
4492 off_t ExpectedSize, time_t ExpectedModTime,
4493 ASTFileSignature ExpectedSignature,
4494 unsigned ClientLoadCapabilities) {
4495 ModuleFile *M;
4496 std::string ErrorStr;
4497 ModuleManager::AddModuleResult AddResult
4498 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4499 getGeneration(), ExpectedSize, ExpectedModTime,
4500 ExpectedSignature, readASTFileSignature,
4501 M, ErrorStr);
4502
4503 switch (AddResult) {
4504 case ModuleManager::AlreadyLoaded:
4505 Diag(diag::remark_module_import)
4506 << M->ModuleName << M->FileName << (ImportedBy ? true : false)
4507 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
4508 return Success;
4509
4510 case ModuleManager::NewlyLoaded:
4511 // Load module file below.
4512 break;
4513
4514 case ModuleManager::Missing:
4515 // The module file was missing; if the client can handle that, return
4516 // it.
4517 if (ClientLoadCapabilities & ARR_Missing)
4518 return Missing;
4519
4520 // Otherwise, return an error.
4521 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4522 << FileName << !ErrorStr.empty()
4523 << ErrorStr;
4524 return Failure;
4525
4526 case ModuleManager::OutOfDate:
4527 // We couldn't load the module file because it is out-of-date. If the
4528 // client can handle out-of-date, return it.
4529 if (ClientLoadCapabilities & ARR_OutOfDate)
4530 return OutOfDate;
4531
4532 // Otherwise, return an error.
4533 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4534 << FileName << !ErrorStr.empty()
4535 << ErrorStr;
4536 return Failure;
4537 }
4538
4539 assert(M && "Missing module file");
4540
4541 bool ShouldFinalizePCM = false;
4542 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4543 auto &MC = getModuleManager().getModuleCache();
4544 if (ShouldFinalizePCM)
4545 MC.finalizePCM(FileName);
4546 else
4547 MC.tryToDropPCM(FileName);
4548 });
4549 ModuleFile &F = *M;
4550 BitstreamCursor &Stream = F.Stream;
4551 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4552 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4553
4554 // Sniff for the signature.
4555 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
4556 Diag(diag::err_module_file_invalid)
4557 << moduleKindForDiagnostic(Type) << FileName << std::move(Err);
4558 return Failure;
4559 }
4560
4561 // This is used for compatibility with older PCH formats.
4562 bool HaveReadControlBlock = false;
4563 while (true) {
4564 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4565 if (!MaybeEntry) {
4566 Error(MaybeEntry.takeError());
4567 return Failure;
4568 }
4569 llvm::BitstreamEntry Entry = MaybeEntry.get();
4570
4571 switch (Entry.Kind) {
4572 case llvm::BitstreamEntry::Error:
4573 case llvm::BitstreamEntry::Record:
4574 case llvm::BitstreamEntry::EndBlock:
4575 Error("invalid record at top-level of AST file");
4576 return Failure;
4577
4578 case llvm::BitstreamEntry::SubBlock:
4579 break;
4580 }
4581
4582 switch (Entry.ID) {
4583 case CONTROL_BLOCK_ID:
4584 HaveReadControlBlock = true;
4585 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4586 case Success:
4587 // Check that we didn't try to load a non-module AST file as a module.
4588 //
4589 // FIXME: Should we also perform the converse check? Loading a module as
4590 // a PCH file sort of works, but it's a bit wonky.
4591 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4592 Type == MK_PrebuiltModule) &&
4593 F.ModuleName.empty()) {
4594 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4595 if (Result != OutOfDate ||
4596 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4597 Diag(diag::err_module_file_not_module) << FileName;
4598 return Result;
4599 }
4600 break;
4601
4602 case Failure: return Failure;
4603 case Missing: return Missing;
4604 case OutOfDate: return OutOfDate;
4605 case VersionMismatch: return VersionMismatch;
4606 case ConfigurationMismatch: return ConfigurationMismatch;
4607 case HadErrors: return HadErrors;
4608 }
4609 break;
4610
4611 case AST_BLOCK_ID:
4612 if (!HaveReadControlBlock) {
4613 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4614 Diag(diag::err_pch_version_too_old);
4615 return VersionMismatch;
4616 }
4617
4618 // Record that we've loaded this module.
4619 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4620 ShouldFinalizePCM = true;
4621 return Success;
4622
4623 case UNHASHED_CONTROL_BLOCK_ID:
4624 // This block is handled using look-ahead during ReadControlBlock. We
4625 // shouldn't get here!
4626 Error("malformed block record in AST file");
4627 return Failure;
4628
4629 default:
4630 if (llvm::Error Err = Stream.SkipBlock()) {
4631 Error(std::move(Err));
4632 return Failure;
4633 }
4634 break;
4635 }
4636 }
4637
4638 llvm_unreachable("unexpected break; expected return");
4639 }
4640
4641 ASTReader::ASTReadResult
readUnhashedControlBlock(ModuleFile & F,bool WasImportedBy,unsigned ClientLoadCapabilities)4642 ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4643 unsigned ClientLoadCapabilities) {
4644 const HeaderSearchOptions &HSOpts =
4645 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4646 bool AllowCompatibleConfigurationMismatch =
4647 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4648
4649 ASTReadResult Result = readUnhashedControlBlockImpl(
4650 &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4651 Listener.get(),
4652 WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4653
4654 // If F was directly imported by another module, it's implicitly validated by
4655 // the importing module.
4656 if (DisableValidation || WasImportedBy ||
4657 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4658 return Success;
4659
4660 if (Result == Failure) {
4661 Error("malformed block record in AST file");
4662 return Failure;
4663 }
4664
4665 if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4666 // If this module has already been finalized in the ModuleCache, we're stuck
4667 // with it; we can only load a single version of each module.
4668 //
4669 // This can happen when a module is imported in two contexts: in one, as a
4670 // user module; in another, as a system module (due to an import from
4671 // another module marked with the [system] flag). It usually indicates a
4672 // bug in the module map: this module should also be marked with [system].
4673 //
4674 // If -Wno-system-headers (the default), and the first import is as a
4675 // system module, then validation will fail during the as-user import,
4676 // since -Werror flags won't have been validated. However, it's reasonable
4677 // to treat this consistently as a system module.
4678 //
4679 // If -Wsystem-headers, the PCM on disk was built with
4680 // -Wno-system-headers, and the first import is as a user module, then
4681 // validation will fail during the as-system import since the PCM on disk
4682 // doesn't guarantee that -Werror was respected. However, the -Werror
4683 // flags were checked during the initial as-user import.
4684 if (getModuleManager().getModuleCache().isPCMFinal(F.FileName)) {
4685 Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4686 return Success;
4687 }
4688 }
4689
4690 return Result;
4691 }
4692
readUnhashedControlBlockImpl(ModuleFile * F,llvm::StringRef StreamData,unsigned ClientLoadCapabilities,bool AllowCompatibleConfigurationMismatch,ASTReaderListener * Listener,bool ValidateDiagnosticOptions)4693 ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4694 ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4695 bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4696 bool ValidateDiagnosticOptions) {
4697 // Initialize a stream.
4698 BitstreamCursor Stream(StreamData);
4699
4700 // Sniff for the signature.
4701 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
4702 // FIXME this drops the error on the floor.
4703 consumeError(std::move(Err));
4704 return Failure;
4705 }
4706
4707 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4708 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4709 return Failure;
4710
4711 // Read all of the records in the options block.
4712 RecordData Record;
4713 ASTReadResult Result = Success;
4714 while (true) {
4715 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4716 if (!MaybeEntry) {
4717 // FIXME this drops the error on the floor.
4718 consumeError(MaybeEntry.takeError());
4719 return Failure;
4720 }
4721 llvm::BitstreamEntry Entry = MaybeEntry.get();
4722
4723 switch (Entry.Kind) {
4724 case llvm::BitstreamEntry::Error:
4725 case llvm::BitstreamEntry::SubBlock:
4726 return Failure;
4727
4728 case llvm::BitstreamEntry::EndBlock:
4729 return Result;
4730
4731 case llvm::BitstreamEntry::Record:
4732 // The interesting case.
4733 break;
4734 }
4735
4736 // Read and process a record.
4737 Record.clear();
4738 Expected<unsigned> MaybeRecordType = Stream.readRecord(Entry.ID, Record);
4739 if (!MaybeRecordType) {
4740 // FIXME this drops the error.
4741 return Failure;
4742 }
4743 switch ((UnhashedControlBlockRecordTypes)MaybeRecordType.get()) {
4744 case SIGNATURE:
4745 if (F)
4746 F->Signature = ASTFileSignature::create(Record.begin(), Record.end());
4747 break;
4748 case AST_BLOCK_HASH:
4749 if (F)
4750 F->ASTBlockHash =
4751 ASTFileSignature::create(Record.begin(), Record.end());
4752 break;
4753 case DIAGNOSTIC_OPTIONS: {
4754 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4755 if (Listener && ValidateDiagnosticOptions &&
4756 !AllowCompatibleConfigurationMismatch &&
4757 ParseDiagnosticOptions(Record, Complain, *Listener))
4758 Result = OutOfDate; // Don't return early. Read the signature.
4759 break;
4760 }
4761 case DIAG_PRAGMA_MAPPINGS:
4762 if (!F)
4763 break;
4764 if (F->PragmaDiagMappings.empty())
4765 F->PragmaDiagMappings.swap(Record);
4766 else
4767 F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4768 Record.begin(), Record.end());
4769 break;
4770 }
4771 }
4772 }
4773
4774 /// Parse a record and blob containing module file extension metadata.
parseModuleFileExtensionMetadata(const SmallVectorImpl<uint64_t> & Record,StringRef Blob,ModuleFileExtensionMetadata & Metadata)4775 static bool parseModuleFileExtensionMetadata(
4776 const SmallVectorImpl<uint64_t> &Record,
4777 StringRef Blob,
4778 ModuleFileExtensionMetadata &Metadata) {
4779 if (Record.size() < 4) return true;
4780
4781 Metadata.MajorVersion = Record[0];
4782 Metadata.MinorVersion = Record[1];
4783
4784 unsigned BlockNameLen = Record[2];
4785 unsigned UserInfoLen = Record[3];
4786
4787 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4788
4789 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4790 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4791 Blob.data() + BlockNameLen + UserInfoLen);
4792 return false;
4793 }
4794
ReadExtensionBlock(ModuleFile & F)4795 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4796 BitstreamCursor &Stream = F.Stream;
4797
4798 RecordData Record;
4799 while (true) {
4800 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
4801 if (!MaybeEntry) {
4802 Error(MaybeEntry.takeError());
4803 return Failure;
4804 }
4805 llvm::BitstreamEntry Entry = MaybeEntry.get();
4806
4807 switch (Entry.Kind) {
4808 case llvm::BitstreamEntry::SubBlock:
4809 if (llvm::Error Err = Stream.SkipBlock()) {
4810 Error(std::move(Err));
4811 return Failure;
4812 }
4813 continue;
4814
4815 case llvm::BitstreamEntry::EndBlock:
4816 return Success;
4817
4818 case llvm::BitstreamEntry::Error:
4819 return HadErrors;
4820
4821 case llvm::BitstreamEntry::Record:
4822 break;
4823 }
4824
4825 Record.clear();
4826 StringRef Blob;
4827 Expected<unsigned> MaybeRecCode =
4828 Stream.readRecord(Entry.ID, Record, &Blob);
4829 if (!MaybeRecCode) {
4830 Error(MaybeRecCode.takeError());
4831 return Failure;
4832 }
4833 switch (MaybeRecCode.get()) {
4834 case EXTENSION_METADATA: {
4835 ModuleFileExtensionMetadata Metadata;
4836 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata)) {
4837 Error("malformed EXTENSION_METADATA in AST file");
4838 return Failure;
4839 }
4840
4841 // Find a module file extension with this block name.
4842 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4843 if (Known == ModuleFileExtensions.end()) break;
4844
4845 // Form a reader.
4846 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4847 F, Stream)) {
4848 F.ExtensionReaders.push_back(std::move(Reader));
4849 }
4850
4851 break;
4852 }
4853 }
4854 }
4855
4856 return Success;
4857 }
4858
InitializeContext()4859 void ASTReader::InitializeContext() {
4860 assert(ContextObj && "no context to initialize");
4861 ASTContext &Context = *ContextObj;
4862
4863 // If there's a listener, notify them that we "read" the translation unit.
4864 if (DeserializationListener)
4865 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4866 Context.getTranslationUnitDecl());
4867
4868 // FIXME: Find a better way to deal with collisions between these
4869 // built-in types. Right now, we just ignore the problem.
4870
4871 // Load the special types.
4872 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4873 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4874 if (!Context.CFConstantStringTypeDecl)
4875 Context.setCFConstantStringType(GetType(String));
4876 }
4877
4878 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4879 QualType FileType = GetType(File);
4880 if (FileType.isNull()) {
4881 Error("FILE type is NULL");
4882 return;
4883 }
4884
4885 if (!Context.FILEDecl) {
4886 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4887 Context.setFILEDecl(Typedef->getDecl());
4888 else {
4889 const TagType *Tag = FileType->getAs<TagType>();
4890 if (!Tag) {
4891 Error("Invalid FILE type in AST file");
4892 return;
4893 }
4894 Context.setFILEDecl(Tag->getDecl());
4895 }
4896 }
4897 }
4898
4899 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4900 QualType Jmp_bufType = GetType(Jmp_buf);
4901 if (Jmp_bufType.isNull()) {
4902 Error("jmp_buf type is NULL");
4903 return;
4904 }
4905
4906 if (!Context.jmp_bufDecl) {
4907 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4908 Context.setjmp_bufDecl(Typedef->getDecl());
4909 else {
4910 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4911 if (!Tag) {
4912 Error("Invalid jmp_buf type in AST file");
4913 return;
4914 }
4915 Context.setjmp_bufDecl(Tag->getDecl());
4916 }
4917 }
4918 }
4919
4920 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4921 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4922 if (Sigjmp_bufType.isNull()) {
4923 Error("sigjmp_buf type is NULL");
4924 return;
4925 }
4926
4927 if (!Context.sigjmp_bufDecl) {
4928 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4929 Context.setsigjmp_bufDecl(Typedef->getDecl());
4930 else {
4931 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4932 assert(Tag && "Invalid sigjmp_buf type in AST file");
4933 Context.setsigjmp_bufDecl(Tag->getDecl());
4934 }
4935 }
4936 }
4937
4938 if (unsigned ObjCIdRedef
4939 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4940 if (Context.ObjCIdRedefinitionType.isNull())
4941 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4942 }
4943
4944 if (unsigned ObjCClassRedef
4945 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4946 if (Context.ObjCClassRedefinitionType.isNull())
4947 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4948 }
4949
4950 if (unsigned ObjCSelRedef
4951 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4952 if (Context.ObjCSelRedefinitionType.isNull())
4953 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4954 }
4955
4956 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4957 QualType Ucontext_tType = GetType(Ucontext_t);
4958 if (Ucontext_tType.isNull()) {
4959 Error("ucontext_t type is NULL");
4960 return;
4961 }
4962
4963 if (!Context.ucontext_tDecl) {
4964 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4965 Context.setucontext_tDecl(Typedef->getDecl());
4966 else {
4967 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4968 assert(Tag && "Invalid ucontext_t type in AST file");
4969 Context.setucontext_tDecl(Tag->getDecl());
4970 }
4971 }
4972 }
4973 }
4974
4975 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4976
4977 // If there were any CUDA special declarations, deserialize them.
4978 if (!CUDASpecialDeclRefs.empty()) {
4979 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4980 Context.setcudaConfigureCallDecl(
4981 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4982 }
4983
4984 // Re-export any modules that were imported by a non-module AST file.
4985 // FIXME: This does not make macro-only imports visible again.
4986 for (auto &Import : ImportedModules) {
4987 if (Module *Imported = getSubmodule(Import.ID)) {
4988 makeModuleVisible(Imported, Module::AllVisible,
4989 /*ImportLoc=*/Import.ImportLoc);
4990 if (Import.ImportLoc.isValid())
4991 PP.makeModuleVisible(Imported, Import.ImportLoc);
4992 // FIXME: should we tell Sema to make the module visible too?
4993 }
4994 }
4995 ImportedModules.clear();
4996 }
4997
finalizeForWriting()4998 void ASTReader::finalizeForWriting() {
4999 // Nothing to do for now.
5000 }
5001
5002 /// Reads and return the signature record from \p PCH's control block, or
5003 /// else returns 0.
readASTFileSignature(StringRef PCH)5004 static ASTFileSignature readASTFileSignature(StringRef PCH) {
5005 BitstreamCursor Stream(PCH);
5006 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5007 // FIXME this drops the error on the floor.
5008 consumeError(std::move(Err));
5009 return ASTFileSignature();
5010 }
5011
5012 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
5013 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
5014 return ASTFileSignature();
5015
5016 // Scan for SIGNATURE inside the diagnostic options block.
5017 ASTReader::RecordData Record;
5018 while (true) {
5019 Expected<llvm::BitstreamEntry> MaybeEntry =
5020 Stream.advanceSkippingSubblocks();
5021 if (!MaybeEntry) {
5022 // FIXME this drops the error on the floor.
5023 consumeError(MaybeEntry.takeError());
5024 return ASTFileSignature();
5025 }
5026 llvm::BitstreamEntry Entry = MaybeEntry.get();
5027
5028 if (Entry.Kind != llvm::BitstreamEntry::Record)
5029 return ASTFileSignature();
5030
5031 Record.clear();
5032 StringRef Blob;
5033 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record, &Blob);
5034 if (!MaybeRecord) {
5035 // FIXME this drops the error on the floor.
5036 consumeError(MaybeRecord.takeError());
5037 return ASTFileSignature();
5038 }
5039 if (SIGNATURE == MaybeRecord.get())
5040 return ASTFileSignature::create(Record.begin(),
5041 Record.begin() + ASTFileSignature::size);
5042 }
5043 }
5044
5045 /// Retrieve the name of the original source file name
5046 /// directly from the AST file, without actually loading the AST
5047 /// file.
getOriginalSourceFile(const std::string & ASTFileName,FileManager & FileMgr,const PCHContainerReader & PCHContainerRdr,DiagnosticsEngine & Diags)5048 std::string ASTReader::getOriginalSourceFile(
5049 const std::string &ASTFileName, FileManager &FileMgr,
5050 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
5051 // Open the AST file.
5052 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
5053 if (!Buffer) {
5054 Diags.Report(diag::err_fe_unable_to_read_pch_file)
5055 << ASTFileName << Buffer.getError().message();
5056 return std::string();
5057 }
5058
5059 // Initialize the stream
5060 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
5061
5062 // Sniff for the signature.
5063 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5064 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName << std::move(Err);
5065 return std::string();
5066 }
5067
5068 // Scan for the CONTROL_BLOCK_ID block.
5069 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
5070 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5071 return std::string();
5072 }
5073
5074 // Scan for ORIGINAL_FILE inside the control block.
5075 RecordData Record;
5076 while (true) {
5077 Expected<llvm::BitstreamEntry> MaybeEntry =
5078 Stream.advanceSkippingSubblocks();
5079 if (!MaybeEntry) {
5080 // FIXME this drops errors on the floor.
5081 consumeError(MaybeEntry.takeError());
5082 return std::string();
5083 }
5084 llvm::BitstreamEntry Entry = MaybeEntry.get();
5085
5086 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
5087 return std::string();
5088
5089 if (Entry.Kind != llvm::BitstreamEntry::Record) {
5090 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
5091 return std::string();
5092 }
5093
5094 Record.clear();
5095 StringRef Blob;
5096 Expected<unsigned> MaybeRecord = Stream.readRecord(Entry.ID, Record, &Blob);
5097 if (!MaybeRecord) {
5098 // FIXME this drops the errors on the floor.
5099 consumeError(MaybeRecord.takeError());
5100 return std::string();
5101 }
5102 if (ORIGINAL_FILE == MaybeRecord.get())
5103 return Blob.str();
5104 }
5105 }
5106
5107 namespace {
5108
5109 class SimplePCHValidator : public ASTReaderListener {
5110 const LangOptions &ExistingLangOpts;
5111 const TargetOptions &ExistingTargetOpts;
5112 const PreprocessorOptions &ExistingPPOpts;
5113 std::string ExistingModuleCachePath;
5114 FileManager &FileMgr;
5115
5116 public:
SimplePCHValidator(const LangOptions & ExistingLangOpts,const TargetOptions & ExistingTargetOpts,const PreprocessorOptions & ExistingPPOpts,StringRef ExistingModuleCachePath,FileManager & FileMgr)5117 SimplePCHValidator(const LangOptions &ExistingLangOpts,
5118 const TargetOptions &ExistingTargetOpts,
5119 const PreprocessorOptions &ExistingPPOpts,
5120 StringRef ExistingModuleCachePath, FileManager &FileMgr)
5121 : ExistingLangOpts(ExistingLangOpts),
5122 ExistingTargetOpts(ExistingTargetOpts),
5123 ExistingPPOpts(ExistingPPOpts),
5124 ExistingModuleCachePath(ExistingModuleCachePath), FileMgr(FileMgr) {}
5125
ReadLanguageOptions(const LangOptions & LangOpts,bool Complain,bool AllowCompatibleDifferences)5126 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
5127 bool AllowCompatibleDifferences) override {
5128 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
5129 AllowCompatibleDifferences);
5130 }
5131
ReadTargetOptions(const TargetOptions & TargetOpts,bool Complain,bool AllowCompatibleDifferences)5132 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
5133 bool AllowCompatibleDifferences) override {
5134 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
5135 AllowCompatibleDifferences);
5136 }
5137
ReadHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,bool Complain)5138 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
5139 StringRef SpecificModuleCachePath,
5140 bool Complain) override {
5141 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5142 ExistingModuleCachePath,
5143 nullptr, ExistingLangOpts);
5144 }
5145
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)5146 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
5147 bool Complain,
5148 std::string &SuggestedPredefines) override {
5149 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
5150 SuggestedPredefines, ExistingLangOpts);
5151 }
5152 };
5153
5154 } // namespace
5155
readASTFileControlBlock(StringRef Filename,FileManager & FileMgr,const PCHContainerReader & PCHContainerRdr,bool FindModuleFileExtensions,ASTReaderListener & Listener,bool ValidateDiagnosticOptions)5156 bool ASTReader::readASTFileControlBlock(
5157 StringRef Filename, FileManager &FileMgr,
5158 const PCHContainerReader &PCHContainerRdr,
5159 bool FindModuleFileExtensions,
5160 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
5161 // Open the AST file.
5162 // FIXME: This allows use of the VFS; we do not allow use of the
5163 // VFS when actually loading a module.
5164 auto Buffer = FileMgr.getBufferForFile(Filename);
5165 if (!Buffer) {
5166 return true;
5167 }
5168
5169 // Initialize the stream
5170 StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
5171 BitstreamCursor Stream(Bytes);
5172
5173 // Sniff for the signature.
5174 if (llvm::Error Err = doesntStartWithASTFileMagic(Stream)) {
5175 consumeError(std::move(Err)); // FIXME this drops errors on the floor.
5176 return true;
5177 }
5178
5179 // Scan for the CONTROL_BLOCK_ID block.
5180 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
5181 return true;
5182
5183 bool NeedsInputFiles = Listener.needsInputFileVisitation();
5184 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
5185 bool NeedsImports = Listener.needsImportVisitation();
5186 BitstreamCursor InputFilesCursor;
5187
5188 RecordData Record;
5189 std::string ModuleDir;
5190 bool DoneWithControlBlock = false;
5191 while (!DoneWithControlBlock) {
5192 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5193 if (!MaybeEntry) {
5194 // FIXME this drops the error on the floor.
5195 consumeError(MaybeEntry.takeError());
5196 return true;
5197 }
5198 llvm::BitstreamEntry Entry = MaybeEntry.get();
5199
5200 switch (Entry.Kind) {
5201 case llvm::BitstreamEntry::SubBlock: {
5202 switch (Entry.ID) {
5203 case OPTIONS_BLOCK_ID: {
5204 std::string IgnoredSuggestedPredefines;
5205 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
5206 /*AllowCompatibleConfigurationMismatch*/ false,
5207 Listener, IgnoredSuggestedPredefines) != Success)
5208 return true;
5209 break;
5210 }
5211
5212 case INPUT_FILES_BLOCK_ID:
5213 InputFilesCursor = Stream;
5214 if (llvm::Error Err = Stream.SkipBlock()) {
5215 // FIXME this drops the error on the floor.
5216 consumeError(std::move(Err));
5217 return true;
5218 }
5219 if (NeedsInputFiles &&
5220 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID))
5221 return true;
5222 break;
5223
5224 default:
5225 if (llvm::Error Err = Stream.SkipBlock()) {
5226 // FIXME this drops the error on the floor.
5227 consumeError(std::move(Err));
5228 return true;
5229 }
5230 break;
5231 }
5232
5233 continue;
5234 }
5235
5236 case llvm::BitstreamEntry::EndBlock:
5237 DoneWithControlBlock = true;
5238 break;
5239
5240 case llvm::BitstreamEntry::Error:
5241 return true;
5242
5243 case llvm::BitstreamEntry::Record:
5244 break;
5245 }
5246
5247 if (DoneWithControlBlock) break;
5248
5249 Record.clear();
5250 StringRef Blob;
5251 Expected<unsigned> MaybeRecCode =
5252 Stream.readRecord(Entry.ID, Record, &Blob);
5253 if (!MaybeRecCode) {
5254 // FIXME this drops the error.
5255 return Failure;
5256 }
5257 switch ((ControlRecordTypes)MaybeRecCode.get()) {
5258 case METADATA:
5259 if (Record[0] != VERSION_MAJOR)
5260 return true;
5261 if (Listener.ReadFullVersionInformation(Blob))
5262 return true;
5263 break;
5264 case MODULE_NAME:
5265 Listener.ReadModuleName(Blob);
5266 break;
5267 case MODULE_DIRECTORY:
5268 ModuleDir = std::string(Blob);
5269 break;
5270 case MODULE_MAP_FILE: {
5271 unsigned Idx = 0;
5272 auto Path = ReadString(Record, Idx);
5273 ResolveImportedPath(Path, ModuleDir);
5274 Listener.ReadModuleMapFile(Path);
5275 break;
5276 }
5277 case INPUT_FILE_OFFSETS: {
5278 if (!NeedsInputFiles)
5279 break;
5280
5281 unsigned NumInputFiles = Record[0];
5282 unsigned NumUserFiles = Record[1];
5283 const llvm::support::unaligned_uint64_t *InputFileOffs =
5284 (const llvm::support::unaligned_uint64_t *)Blob.data();
5285 for (unsigned I = 0; I != NumInputFiles; ++I) {
5286 // Go find this input file.
5287 bool isSystemFile = I >= NumUserFiles;
5288
5289 if (isSystemFile && !NeedsSystemInputFiles)
5290 break; // the rest are system input files
5291
5292 BitstreamCursor &Cursor = InputFilesCursor;
5293 SavedStreamPosition SavedPosition(Cursor);
5294 if (llvm::Error Err = Cursor.JumpToBit(InputFileOffs[I])) {
5295 // FIXME this drops errors on the floor.
5296 consumeError(std::move(Err));
5297 }
5298
5299 Expected<unsigned> MaybeCode = Cursor.ReadCode();
5300 if (!MaybeCode) {
5301 // FIXME this drops errors on the floor.
5302 consumeError(MaybeCode.takeError());
5303 }
5304 unsigned Code = MaybeCode.get();
5305
5306 RecordData Record;
5307 StringRef Blob;
5308 bool shouldContinue = false;
5309 Expected<unsigned> MaybeRecordType =
5310 Cursor.readRecord(Code, Record, &Blob);
5311 if (!MaybeRecordType) {
5312 // FIXME this drops errors on the floor.
5313 consumeError(MaybeRecordType.takeError());
5314 }
5315 switch ((InputFileRecordTypes)MaybeRecordType.get()) {
5316 case INPUT_FILE_HASH:
5317 break;
5318 case INPUT_FILE:
5319 bool Overridden = static_cast<bool>(Record[3]);
5320 std::string Filename = std::string(Blob);
5321 ResolveImportedPath(Filename, ModuleDir);
5322 shouldContinue = Listener.visitInputFile(
5323 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
5324 break;
5325 }
5326 if (!shouldContinue)
5327 break;
5328 }
5329 break;
5330 }
5331
5332 case IMPORTS: {
5333 if (!NeedsImports)
5334 break;
5335
5336 unsigned Idx = 0, N = Record.size();
5337 while (Idx < N) {
5338 // Read information about the AST file.
5339 Idx +=
5340 1 + 1 + 1 + 1 +
5341 ASTFileSignature::size; // Kind, ImportLoc, Size, ModTime, Signature
5342 std::string ModuleName = ReadString(Record, Idx);
5343 std::string Filename = ReadString(Record, Idx);
5344 ResolveImportedPath(Filename, ModuleDir);
5345 Listener.visitImport(ModuleName, Filename);
5346 }
5347 break;
5348 }
5349
5350 default:
5351 // No other validation to perform.
5352 break;
5353 }
5354 }
5355
5356 // Look for module file extension blocks, if requested.
5357 if (FindModuleFileExtensions) {
5358 BitstreamCursor SavedStream = Stream;
5359 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
5360 bool DoneWithExtensionBlock = false;
5361 while (!DoneWithExtensionBlock) {
5362 Expected<llvm::BitstreamEntry> MaybeEntry = Stream.advance();
5363 if (!MaybeEntry) {
5364 // FIXME this drops the error.
5365 return true;
5366 }
5367 llvm::BitstreamEntry Entry = MaybeEntry.get();
5368
5369 switch (Entry.Kind) {
5370 case llvm::BitstreamEntry::SubBlock:
5371 if (llvm::Error Err = Stream.SkipBlock()) {
5372 // FIXME this drops the error on the floor.
5373 consumeError(std::move(Err));
5374 return true;
5375 }
5376 continue;
5377
5378 case llvm::BitstreamEntry::EndBlock:
5379 DoneWithExtensionBlock = true;
5380 continue;
5381
5382 case llvm::BitstreamEntry::Error:
5383 return true;
5384
5385 case llvm::BitstreamEntry::Record:
5386 break;
5387 }
5388
5389 Record.clear();
5390 StringRef Blob;
5391 Expected<unsigned> MaybeRecCode =
5392 Stream.readRecord(Entry.ID, Record, &Blob);
5393 if (!MaybeRecCode) {
5394 // FIXME this drops the error.
5395 return true;
5396 }
5397 switch (MaybeRecCode.get()) {
5398 case EXTENSION_METADATA: {
5399 ModuleFileExtensionMetadata Metadata;
5400 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
5401 return true;
5402
5403 Listener.readModuleFileExtension(Metadata);
5404 break;
5405 }
5406 }
5407 }
5408 }
5409 Stream = SavedStream;
5410 }
5411
5412 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
5413 if (readUnhashedControlBlockImpl(
5414 nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
5415 /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
5416 ValidateDiagnosticOptions) != Success)
5417 return true;
5418
5419 return false;
5420 }
5421
isAcceptableASTFile(StringRef Filename,FileManager & FileMgr,const PCHContainerReader & PCHContainerRdr,const LangOptions & LangOpts,const TargetOptions & TargetOpts,const PreprocessorOptions & PPOpts,StringRef ExistingModuleCachePath)5422 bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
5423 const PCHContainerReader &PCHContainerRdr,
5424 const LangOptions &LangOpts,
5425 const TargetOptions &TargetOpts,
5426 const PreprocessorOptions &PPOpts,
5427 StringRef ExistingModuleCachePath) {
5428 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
5429 ExistingModuleCachePath, FileMgr);
5430 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
5431 /*FindModuleFileExtensions=*/false,
5432 validator,
5433 /*ValidateDiagnosticOptions=*/true);
5434 }
5435
5436 ASTReader::ASTReadResult
ReadSubmoduleBlock(ModuleFile & F,unsigned ClientLoadCapabilities)5437 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
5438 // Enter the submodule block.
5439 if (llvm::Error Err = F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
5440 Error(std::move(Err));
5441 return Failure;
5442 }
5443
5444 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
5445 bool First = true;
5446 Module *CurrentModule = nullptr;
5447 RecordData Record;
5448 while (true) {
5449 Expected<llvm::BitstreamEntry> MaybeEntry =
5450 F.Stream.advanceSkippingSubblocks();
5451 if (!MaybeEntry) {
5452 Error(MaybeEntry.takeError());
5453 return Failure;
5454 }
5455 llvm::BitstreamEntry Entry = MaybeEntry.get();
5456
5457 switch (Entry.Kind) {
5458 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
5459 case llvm::BitstreamEntry::Error:
5460 Error("malformed block record in AST file");
5461 return Failure;
5462 case llvm::BitstreamEntry::EndBlock:
5463 return Success;
5464 case llvm::BitstreamEntry::Record:
5465 // The interesting case.
5466 break;
5467 }
5468
5469 // Read a record.
5470 StringRef Blob;
5471 Record.clear();
5472 Expected<unsigned> MaybeKind = F.Stream.readRecord(Entry.ID, Record, &Blob);
5473 if (!MaybeKind) {
5474 Error(MaybeKind.takeError());
5475 return Failure;
5476 }
5477 unsigned Kind = MaybeKind.get();
5478
5479 if ((Kind == SUBMODULE_METADATA) != First) {
5480 Error("submodule metadata record should be at beginning of block");
5481 return Failure;
5482 }
5483 First = false;
5484
5485 // Submodule information is only valid if we have a current module.
5486 // FIXME: Should we error on these cases?
5487 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
5488 Kind != SUBMODULE_DEFINITION)
5489 continue;
5490
5491 switch (Kind) {
5492 default: // Default behavior: ignore.
5493 break;
5494
5495 case SUBMODULE_DEFINITION: {
5496 if (Record.size() < 12) {
5497 Error("malformed module definition");
5498 return Failure;
5499 }
5500
5501 StringRef Name = Blob;
5502 unsigned Idx = 0;
5503 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5504 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5505 Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5506 bool IsFramework = Record[Idx++];
5507 bool IsExplicit = Record[Idx++];
5508 bool IsSystem = Record[Idx++];
5509 bool IsExternC = Record[Idx++];
5510 bool InferSubmodules = Record[Idx++];
5511 bool InferExplicitSubmodules = Record[Idx++];
5512 bool InferExportWildcard = Record[Idx++];
5513 bool ConfigMacrosExhaustive = Record[Idx++];
5514 bool ModuleMapIsPrivate = Record[Idx++];
5515
5516 Module *ParentModule = nullptr;
5517 if (Parent)
5518 ParentModule = getSubmodule(Parent);
5519
5520 // Retrieve this (sub)module from the module map, creating it if
5521 // necessary.
5522 CurrentModule =
5523 ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5524 .first;
5525
5526 // FIXME: set the definition loc for CurrentModule, or call
5527 // ModMap.setInferredModuleAllowedBy()
5528
5529 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5530 if (GlobalIndex >= SubmodulesLoaded.size() ||
5531 SubmodulesLoaded[GlobalIndex]) {
5532 Error("too many submodules");
5533 return Failure;
5534 }
5535
5536 if (!ParentModule) {
5537 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5538 // Don't emit module relocation error if we have -fno-validate-pch
5539 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5540 CurFile != F.File) {
5541 Error(diag::err_module_file_conflict,
5542 CurrentModule->getTopLevelModuleName(), CurFile->getName(),
5543 F.File->getName());
5544 return Failure;
5545 }
5546 }
5547
5548 F.DidReadTopLevelSubmodule = true;
5549 CurrentModule->setASTFile(F.File);
5550 CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5551 }
5552
5553 CurrentModule->Kind = Kind;
5554 CurrentModule->Signature = F.Signature;
5555 CurrentModule->IsFromModuleFile = true;
5556 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5557 CurrentModule->IsExternC = IsExternC;
5558 CurrentModule->InferSubmodules = InferSubmodules;
5559 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5560 CurrentModule->InferExportWildcard = InferExportWildcard;
5561 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5562 CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5563 if (DeserializationListener)
5564 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5565
5566 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5567
5568 // Clear out data that will be replaced by what is in the module file.
5569 CurrentModule->LinkLibraries.clear();
5570 CurrentModule->ConfigMacros.clear();
5571 CurrentModule->UnresolvedConflicts.clear();
5572 CurrentModule->Conflicts.clear();
5573
5574 // The module is available unless it's missing a requirement; relevant
5575 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5576 // Missing headers that were present when the module was built do not
5577 // make it unavailable -- if we got this far, this must be an explicitly
5578 // imported module file.
5579 CurrentModule->Requirements.clear();
5580 CurrentModule->MissingHeaders.clear();
5581 CurrentModule->IsUnimportable =
5582 ParentModule && ParentModule->IsUnimportable;
5583 CurrentModule->IsAvailable = !CurrentModule->IsUnimportable;
5584 break;
5585 }
5586
5587 case SUBMODULE_UMBRELLA_HEADER: {
5588 std::string Filename = std::string(Blob);
5589 ResolveImportedPath(F, Filename);
5590 if (auto Umbrella = PP.getFileManager().getFile(Filename)) {
5591 if (!CurrentModule->getUmbrellaHeader())
5592 ModMap.setUmbrellaHeader(CurrentModule, *Umbrella, Blob);
5593 else if (CurrentModule->getUmbrellaHeader().Entry != *Umbrella) {
5594 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5595 Error("mismatched umbrella headers in submodule");
5596 return OutOfDate;
5597 }
5598 }
5599 break;
5600 }
5601
5602 case SUBMODULE_HEADER:
5603 case SUBMODULE_EXCLUDED_HEADER:
5604 case SUBMODULE_PRIVATE_HEADER:
5605 // We lazily associate headers with their modules via the HeaderInfo table.
5606 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5607 // of complete filenames or remove it entirely.
5608 break;
5609
5610 case SUBMODULE_TEXTUAL_HEADER:
5611 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5612 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5613 // them here.
5614 break;
5615
5616 case SUBMODULE_TOPHEADER:
5617 CurrentModule->addTopHeaderFilename(Blob);
5618 break;
5619
5620 case SUBMODULE_UMBRELLA_DIR: {
5621 std::string Dirname = std::string(Blob);
5622 ResolveImportedPath(F, Dirname);
5623 if (auto Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5624 if (!CurrentModule->getUmbrellaDir())
5625 ModMap.setUmbrellaDir(CurrentModule, *Umbrella, Blob);
5626 else if (CurrentModule->getUmbrellaDir().Entry != *Umbrella) {
5627 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5628 Error("mismatched umbrella directories in submodule");
5629 return OutOfDate;
5630 }
5631 }
5632 break;
5633 }
5634
5635 case SUBMODULE_METADATA: {
5636 F.BaseSubmoduleID = getTotalNumSubmodules();
5637 F.LocalNumSubmodules = Record[0];
5638 unsigned LocalBaseSubmoduleID = Record[1];
5639 if (F.LocalNumSubmodules > 0) {
5640 // Introduce the global -> local mapping for submodules within this
5641 // module.
5642 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5643
5644 // Introduce the local -> global mapping for submodules within this
5645 // module.
5646 F.SubmoduleRemap.insertOrReplace(
5647 std::make_pair(LocalBaseSubmoduleID,
5648 F.BaseSubmoduleID - LocalBaseSubmoduleID));
5649
5650 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5651 }
5652 break;
5653 }
5654
5655 case SUBMODULE_IMPORTS:
5656 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5657 UnresolvedModuleRef Unresolved;
5658 Unresolved.File = &F;
5659 Unresolved.Mod = CurrentModule;
5660 Unresolved.ID = Record[Idx];
5661 Unresolved.Kind = UnresolvedModuleRef::Import;
5662 Unresolved.IsWildcard = false;
5663 UnresolvedModuleRefs.push_back(Unresolved);
5664 }
5665 break;
5666
5667 case SUBMODULE_EXPORTS:
5668 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5669 UnresolvedModuleRef Unresolved;
5670 Unresolved.File = &F;
5671 Unresolved.Mod = CurrentModule;
5672 Unresolved.ID = Record[Idx];
5673 Unresolved.Kind = UnresolvedModuleRef::Export;
5674 Unresolved.IsWildcard = Record[Idx + 1];
5675 UnresolvedModuleRefs.push_back(Unresolved);
5676 }
5677
5678 // Once we've loaded the set of exports, there's no reason to keep
5679 // the parsed, unresolved exports around.
5680 CurrentModule->UnresolvedExports.clear();
5681 break;
5682
5683 case SUBMODULE_REQUIRES:
5684 CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5685 PP.getTargetInfo());
5686 break;
5687
5688 case SUBMODULE_LINK_LIBRARY:
5689 ModMap.resolveLinkAsDependencies(CurrentModule);
5690 CurrentModule->LinkLibraries.push_back(
5691 Module::LinkLibrary(std::string(Blob), Record[0]));
5692 break;
5693
5694 case SUBMODULE_CONFIG_MACRO:
5695 CurrentModule->ConfigMacros.push_back(Blob.str());
5696 break;
5697
5698 case SUBMODULE_CONFLICT: {
5699 UnresolvedModuleRef Unresolved;
5700 Unresolved.File = &F;
5701 Unresolved.Mod = CurrentModule;
5702 Unresolved.ID = Record[0];
5703 Unresolved.Kind = UnresolvedModuleRef::Conflict;
5704 Unresolved.IsWildcard = false;
5705 Unresolved.String = Blob;
5706 UnresolvedModuleRefs.push_back(Unresolved);
5707 break;
5708 }
5709
5710 case SUBMODULE_INITIALIZERS: {
5711 if (!ContextObj)
5712 break;
5713 SmallVector<uint32_t, 16> Inits;
5714 for (auto &ID : Record)
5715 Inits.push_back(getGlobalDeclID(F, ID));
5716 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5717 break;
5718 }
5719
5720 case SUBMODULE_EXPORT_AS:
5721 CurrentModule->ExportAsModule = Blob.str();
5722 ModMap.addLinkAsDependency(CurrentModule);
5723 break;
5724 }
5725 }
5726 }
5727
5728 /// Parse the record that corresponds to a LangOptions data
5729 /// structure.
5730 ///
5731 /// This routine parses the language options from the AST file and then gives
5732 /// them to the AST listener if one is set.
5733 ///
5734 /// \returns true if the listener deems the file unacceptable, false otherwise.
ParseLanguageOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener,bool AllowCompatibleDifferences)5735 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5736 bool Complain,
5737 ASTReaderListener &Listener,
5738 bool AllowCompatibleDifferences) {
5739 LangOptions LangOpts;
5740 unsigned Idx = 0;
5741 #define LANGOPT(Name, Bits, Default, Description) \
5742 LangOpts.Name = Record[Idx++];
5743 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5744 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5745 #include "clang/Basic/LangOptions.def"
5746 #define SANITIZER(NAME, ID) \
5747 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5748 #include "clang/Basic/Sanitizers.def"
5749
5750 for (unsigned N = Record[Idx++]; N; --N)
5751 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5752
5753 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5754 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5755 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5756
5757 LangOpts.CurrentModule = ReadString(Record, Idx);
5758
5759 // Comment options.
5760 for (unsigned N = Record[Idx++]; N; --N) {
5761 LangOpts.CommentOpts.BlockCommandNames.push_back(
5762 ReadString(Record, Idx));
5763 }
5764 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5765
5766 // OpenMP offloading options.
5767 for (unsigned N = Record[Idx++]; N; --N) {
5768 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5769 }
5770
5771 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5772
5773 return Listener.ReadLanguageOptions(LangOpts, Complain,
5774 AllowCompatibleDifferences);
5775 }
5776
ParseTargetOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener,bool AllowCompatibleDifferences)5777 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5778 ASTReaderListener &Listener,
5779 bool AllowCompatibleDifferences) {
5780 unsigned Idx = 0;
5781 TargetOptions TargetOpts;
5782 TargetOpts.Triple = ReadString(Record, Idx);
5783 TargetOpts.CPU = ReadString(Record, Idx);
5784 TargetOpts.ABI = ReadString(Record, Idx);
5785 for (unsigned N = Record[Idx++]; N; --N) {
5786 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5787 }
5788 for (unsigned N = Record[Idx++]; N; --N) {
5789 TargetOpts.Features.push_back(ReadString(Record, Idx));
5790 }
5791
5792 return Listener.ReadTargetOptions(TargetOpts, Complain,
5793 AllowCompatibleDifferences);
5794 }
5795
ParseDiagnosticOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener)5796 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5797 ASTReaderListener &Listener) {
5798 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
5799 unsigned Idx = 0;
5800 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5801 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5802 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5803 #include "clang/Basic/DiagnosticOptions.def"
5804
5805 for (unsigned N = Record[Idx++]; N; --N)
5806 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5807 for (unsigned N = Record[Idx++]; N; --N)
5808 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5809
5810 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5811 }
5812
ParseFileSystemOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener)5813 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5814 ASTReaderListener &Listener) {
5815 FileSystemOptions FSOpts;
5816 unsigned Idx = 0;
5817 FSOpts.WorkingDir = ReadString(Record, Idx);
5818 return Listener.ReadFileSystemOptions(FSOpts, Complain);
5819 }
5820
ParseHeaderSearchOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener)5821 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5822 bool Complain,
5823 ASTReaderListener &Listener) {
5824 HeaderSearchOptions HSOpts;
5825 unsigned Idx = 0;
5826 HSOpts.Sysroot = ReadString(Record, Idx);
5827
5828 // Include entries.
5829 for (unsigned N = Record[Idx++]; N; --N) {
5830 std::string Path = ReadString(Record, Idx);
5831 frontend::IncludeDirGroup Group
5832 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5833 bool IsFramework = Record[Idx++];
5834 bool IgnoreSysRoot = Record[Idx++];
5835 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5836 IgnoreSysRoot);
5837 }
5838
5839 // System header prefixes.
5840 for (unsigned N = Record[Idx++]; N; --N) {
5841 std::string Prefix = ReadString(Record, Idx);
5842 bool IsSystemHeader = Record[Idx++];
5843 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5844 }
5845
5846 HSOpts.ResourceDir = ReadString(Record, Idx);
5847 HSOpts.ModuleCachePath = ReadString(Record, Idx);
5848 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5849 HSOpts.DisableModuleHash = Record[Idx++];
5850 HSOpts.ImplicitModuleMaps = Record[Idx++];
5851 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5852 HSOpts.UseBuiltinIncludes = Record[Idx++];
5853 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5854 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5855 HSOpts.UseLibcxx = Record[Idx++];
5856 std::string SpecificModuleCachePath = ReadString(Record, Idx);
5857
5858 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5859 Complain);
5860 }
5861
ParsePreprocessorOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener,std::string & SuggestedPredefines)5862 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5863 bool Complain,
5864 ASTReaderListener &Listener,
5865 std::string &SuggestedPredefines) {
5866 PreprocessorOptions PPOpts;
5867 unsigned Idx = 0;
5868
5869 // Macro definitions/undefs
5870 for (unsigned N = Record[Idx++]; N; --N) {
5871 std::string Macro = ReadString(Record, Idx);
5872 bool IsUndef = Record[Idx++];
5873 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5874 }
5875
5876 // Includes
5877 for (unsigned N = Record[Idx++]; N; --N) {
5878 PPOpts.Includes.push_back(ReadString(Record, Idx));
5879 }
5880
5881 // Macro Includes
5882 for (unsigned N = Record[Idx++]; N; --N) {
5883 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5884 }
5885
5886 PPOpts.UsePredefines = Record[Idx++];
5887 PPOpts.DetailedRecord = Record[Idx++];
5888 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5889 PPOpts.ObjCXXARCStandardLibrary =
5890 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5891 SuggestedPredefines.clear();
5892 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5893 SuggestedPredefines);
5894 }
5895
5896 std::pair<ModuleFile *, unsigned>
getModulePreprocessedEntity(unsigned GlobalIndex)5897 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5898 GlobalPreprocessedEntityMapType::iterator
5899 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5900 assert(I != GlobalPreprocessedEntityMap.end() &&
5901 "Corrupted global preprocessed entity map");
5902 ModuleFile *M = I->second;
5903 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5904 return std::make_pair(M, LocalIndex);
5905 }
5906
5907 llvm::iterator_range<PreprocessingRecord::iterator>
getModulePreprocessedEntities(ModuleFile & Mod) const5908 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5909 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5910 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5911 Mod.NumPreprocessedEntities);
5912
5913 return llvm::make_range(PreprocessingRecord::iterator(),
5914 PreprocessingRecord::iterator());
5915 }
5916
5917 llvm::iterator_range<ASTReader::ModuleDeclIterator>
getModuleFileLevelDecls(ModuleFile & Mod)5918 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
5919 return llvm::make_range(
5920 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5921 ModuleDeclIterator(this, &Mod,
5922 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5923 }
5924
ReadSkippedRange(unsigned GlobalIndex)5925 SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
5926 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5927 assert(I != GlobalSkippedRangeMap.end() &&
5928 "Corrupted global skipped range map");
5929 ModuleFile *M = I->second;
5930 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5931 assert(LocalIndex < M->NumPreprocessedSkippedRanges);
5932 PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5933 SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5934 TranslateSourceLocation(*M, RawRange.getEnd()));
5935 assert(Range.isValid());
5936 return Range;
5937 }
5938
ReadPreprocessedEntity(unsigned Index)5939 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
5940 PreprocessedEntityID PPID = Index+1;
5941 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5942 ModuleFile &M = *PPInfo.first;
5943 unsigned LocalIndex = PPInfo.second;
5944 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5945
5946 if (!PP.getPreprocessingRecord()) {
5947 Error("no preprocessing record");
5948 return nullptr;
5949 }
5950
5951 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5952 if (llvm::Error Err = M.PreprocessorDetailCursor.JumpToBit(
5953 M.MacroOffsetsBase + PPOffs.BitOffset)) {
5954 Error(std::move(Err));
5955 return nullptr;
5956 }
5957
5958 Expected<llvm::BitstreamEntry> MaybeEntry =
5959 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5960 if (!MaybeEntry) {
5961 Error(MaybeEntry.takeError());
5962 return nullptr;
5963 }
5964 llvm::BitstreamEntry Entry = MaybeEntry.get();
5965
5966 if (Entry.Kind != llvm::BitstreamEntry::Record)
5967 return nullptr;
5968
5969 // Read the record.
5970 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5971 TranslateSourceLocation(M, PPOffs.getEnd()));
5972 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5973 StringRef Blob;
5974 RecordData Record;
5975 Expected<unsigned> MaybeRecType =
5976 M.PreprocessorDetailCursor.readRecord(Entry.ID, Record, &Blob);
5977 if (!MaybeRecType) {
5978 Error(MaybeRecType.takeError());
5979 return nullptr;
5980 }
5981 switch ((PreprocessorDetailRecordTypes)MaybeRecType.get()) {
5982 case PPD_MACRO_EXPANSION: {
5983 bool isBuiltin = Record[0];
5984 IdentifierInfo *Name = nullptr;
5985 MacroDefinitionRecord *Def = nullptr;
5986 if (isBuiltin)
5987 Name = getLocalIdentifier(M, Record[1]);
5988 else {
5989 PreprocessedEntityID GlobalID =
5990 getGlobalPreprocessedEntityID(M, Record[1]);
5991 Def = cast<MacroDefinitionRecord>(
5992 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5993 }
5994
5995 MacroExpansion *ME;
5996 if (isBuiltin)
5997 ME = new (PPRec) MacroExpansion(Name, Range);
5998 else
5999 ME = new (PPRec) MacroExpansion(Def, Range);
6000
6001 return ME;
6002 }
6003
6004 case PPD_MACRO_DEFINITION: {
6005 // Decode the identifier info and then check again; if the macro is
6006 // still defined and associated with the identifier,
6007 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
6008 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
6009
6010 if (DeserializationListener)
6011 DeserializationListener->MacroDefinitionRead(PPID, MD);
6012
6013 return MD;
6014 }
6015
6016 case PPD_INCLUSION_DIRECTIVE: {
6017 const char *FullFileNameStart = Blob.data() + Record[0];
6018 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
6019 const FileEntry *File = nullptr;
6020 if (!FullFileName.empty())
6021 if (auto FE = PP.getFileManager().getFile(FullFileName))
6022 File = *FE;
6023
6024 // FIXME: Stable encoding
6025 InclusionDirective::InclusionKind Kind
6026 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
6027 InclusionDirective *ID
6028 = new (PPRec) InclusionDirective(PPRec, Kind,
6029 StringRef(Blob.data(), Record[0]),
6030 Record[1], Record[3],
6031 File,
6032 Range);
6033 return ID;
6034 }
6035 }
6036
6037 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
6038 }
6039
6040 /// Find the next module that contains entities and return the ID
6041 /// of the first entry.
6042 ///
6043 /// \param SLocMapI points at a chunk of a module that contains no
6044 /// preprocessed entities or the entities it contains are not the ones we are
6045 /// looking for.
findNextPreprocessedEntity(GlobalSLocOffsetMapType::const_iterator SLocMapI) const6046 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
6047 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
6048 ++SLocMapI;
6049 for (GlobalSLocOffsetMapType::const_iterator
6050 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
6051 ModuleFile &M = *SLocMapI->second;
6052 if (M.NumPreprocessedEntities)
6053 return M.BasePreprocessedEntityID;
6054 }
6055
6056 return getTotalNumPreprocessedEntities();
6057 }
6058
6059 namespace {
6060
6061 struct PPEntityComp {
6062 const ASTReader &Reader;
6063 ModuleFile &M;
6064
PPEntityComp__anon55dba4300b11::PPEntityComp6065 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
6066
operator ()__anon55dba4300b11::PPEntityComp6067 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
6068 SourceLocation LHS = getLoc(L);
6069 SourceLocation RHS = getLoc(R);
6070 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6071 }
6072
operator ()__anon55dba4300b11::PPEntityComp6073 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
6074 SourceLocation LHS = getLoc(L);
6075 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6076 }
6077
operator ()__anon55dba4300b11::PPEntityComp6078 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
6079 SourceLocation RHS = getLoc(R);
6080 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6081 }
6082
getLoc__anon55dba4300b11::PPEntityComp6083 SourceLocation getLoc(const PPEntityOffset &PPE) const {
6084 return Reader.TranslateSourceLocation(M, PPE.getBegin());
6085 }
6086 };
6087
6088 } // namespace
6089
findPreprocessedEntity(SourceLocation Loc,bool EndsAfter) const6090 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
6091 bool EndsAfter) const {
6092 if (SourceMgr.isLocalSourceLocation(Loc))
6093 return getTotalNumPreprocessedEntities();
6094
6095 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
6096 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
6097 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
6098 "Corrupted global sloc offset map");
6099
6100 if (SLocMapI->second->NumPreprocessedEntities == 0)
6101 return findNextPreprocessedEntity(SLocMapI);
6102
6103 ModuleFile &M = *SLocMapI->second;
6104
6105 using pp_iterator = const PPEntityOffset *;
6106
6107 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
6108 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
6109
6110 size_t Count = M.NumPreprocessedEntities;
6111 size_t Half;
6112 pp_iterator First = pp_begin;
6113 pp_iterator PPI;
6114
6115 if (EndsAfter) {
6116 PPI = std::upper_bound(pp_begin, pp_end, Loc,
6117 PPEntityComp(*this, M));
6118 } else {
6119 // Do a binary search manually instead of using std::lower_bound because
6120 // The end locations of entities may be unordered (when a macro expansion
6121 // is inside another macro argument), but for this case it is not important
6122 // whether we get the first macro expansion or its containing macro.
6123 while (Count > 0) {
6124 Half = Count / 2;
6125 PPI = First;
6126 std::advance(PPI, Half);
6127 if (SourceMgr.isBeforeInTranslationUnit(
6128 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
6129 First = PPI;
6130 ++First;
6131 Count = Count - Half - 1;
6132 } else
6133 Count = Half;
6134 }
6135 }
6136
6137 if (PPI == pp_end)
6138 return findNextPreprocessedEntity(SLocMapI);
6139
6140 return M.BasePreprocessedEntityID + (PPI - pp_begin);
6141 }
6142
6143 /// Returns a pair of [Begin, End) indices of preallocated
6144 /// preprocessed entities that \arg Range encompasses.
6145 std::pair<unsigned, unsigned>
findPreprocessedEntitiesInRange(SourceRange Range)6146 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
6147 if (Range.isInvalid())
6148 return std::make_pair(0,0);
6149 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
6150
6151 PreprocessedEntityID BeginID =
6152 findPreprocessedEntity(Range.getBegin(), false);
6153 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
6154 return std::make_pair(BeginID, EndID);
6155 }
6156
6157 /// Optionally returns true or false if the preallocated preprocessed
6158 /// entity with index \arg Index came from file \arg FID.
isPreprocessedEntityInFileID(unsigned Index,FileID FID)6159 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
6160 FileID FID) {
6161 if (FID.isInvalid())
6162 return false;
6163
6164 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
6165 ModuleFile &M = *PPInfo.first;
6166 unsigned LocalIndex = PPInfo.second;
6167 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
6168
6169 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
6170 if (Loc.isInvalid())
6171 return false;
6172
6173 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
6174 return true;
6175 else
6176 return false;
6177 }
6178
6179 namespace {
6180
6181 /// Visitor used to search for information about a header file.
6182 class HeaderFileInfoVisitor {
6183 const FileEntry *FE;
6184 Optional<HeaderFileInfo> HFI;
6185
6186 public:
HeaderFileInfoVisitor(const FileEntry * FE)6187 explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
6188
operator ()(ModuleFile & M)6189 bool operator()(ModuleFile &M) {
6190 HeaderFileInfoLookupTable *Table
6191 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
6192 if (!Table)
6193 return false;
6194
6195 // Look in the on-disk hash table for an entry for this file name.
6196 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
6197 if (Pos == Table->end())
6198 return false;
6199
6200 HFI = *Pos;
6201 return true;
6202 }
6203
getHeaderFileInfo() const6204 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
6205 };
6206
6207 } // namespace
6208
GetHeaderFileInfo(const FileEntry * FE)6209 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
6210 HeaderFileInfoVisitor Visitor(FE);
6211 ModuleMgr.visit(Visitor);
6212 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
6213 return *HFI;
6214
6215 return HeaderFileInfo();
6216 }
6217
ReadPragmaDiagnosticMappings(DiagnosticsEngine & Diag)6218 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
6219 using DiagState = DiagnosticsEngine::DiagState;
6220 SmallVector<DiagState *, 32> DiagStates;
6221
6222 for (ModuleFile &F : ModuleMgr) {
6223 unsigned Idx = 0;
6224 auto &Record = F.PragmaDiagMappings;
6225 if (Record.empty())
6226 continue;
6227
6228 DiagStates.clear();
6229
6230 auto ReadDiagState =
6231 [&](const DiagState &BasedOn, SourceLocation Loc,
6232 bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
6233 unsigned BackrefID = Record[Idx++];
6234 if (BackrefID != 0)
6235 return DiagStates[BackrefID - 1];
6236
6237 // A new DiagState was created here.
6238 Diag.DiagStates.push_back(BasedOn);
6239 DiagState *NewState = &Diag.DiagStates.back();
6240 DiagStates.push_back(NewState);
6241 unsigned Size = Record[Idx++];
6242 assert(Idx + Size * 2 <= Record.size() &&
6243 "Invalid data, not enough diag/map pairs");
6244 while (Size--) {
6245 unsigned DiagID = Record[Idx++];
6246 DiagnosticMapping NewMapping =
6247 DiagnosticMapping::deserialize(Record[Idx++]);
6248 if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
6249 continue;
6250
6251 DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
6252
6253 // If this mapping was specified as a warning but the severity was
6254 // upgraded due to diagnostic settings, simulate the current diagnostic
6255 // settings (and use a warning).
6256 if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
6257 NewMapping.setSeverity(diag::Severity::Warning);
6258 NewMapping.setUpgradedFromWarning(false);
6259 }
6260
6261 Mapping = NewMapping;
6262 }
6263 return NewState;
6264 };
6265
6266 // Read the first state.
6267 DiagState *FirstState;
6268 if (F.Kind == MK_ImplicitModule) {
6269 // Implicitly-built modules are reused with different diagnostic
6270 // settings. Use the initial diagnostic state from Diag to simulate this
6271 // compilation's diagnostic settings.
6272 FirstState = Diag.DiagStatesByLoc.FirstDiagState;
6273 DiagStates.push_back(FirstState);
6274
6275 // Skip the initial diagnostic state from the serialized module.
6276 assert(Record[1] == 0 &&
6277 "Invalid data, unexpected backref in initial state");
6278 Idx = 3 + Record[2] * 2;
6279 assert(Idx < Record.size() &&
6280 "Invalid data, not enough state change pairs in initial state");
6281 } else if (F.isModule()) {
6282 // For an explicit module, preserve the flags from the module build
6283 // command line (-w, -Weverything, -Werror, ...) along with any explicit
6284 // -Wblah flags.
6285 unsigned Flags = Record[Idx++];
6286 DiagState Initial;
6287 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
6288 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
6289 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
6290 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
6291 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
6292 Initial.ExtBehavior = (diag::Severity)Flags;
6293 FirstState = ReadDiagState(Initial, SourceLocation(), true);
6294
6295 assert(F.OriginalSourceFileID.isValid());
6296
6297 // Set up the root buffer of the module to start with the initial
6298 // diagnostic state of the module itself, to cover files that contain no
6299 // explicit transitions (for which we did not serialize anything).
6300 Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
6301 .StateTransitions.push_back({FirstState, 0});
6302 } else {
6303 // For prefix ASTs, start with whatever the user configured on the
6304 // command line.
6305 Idx++; // Skip flags.
6306 FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
6307 SourceLocation(), false);
6308 }
6309
6310 // Read the state transitions.
6311 unsigned NumLocations = Record[Idx++];
6312 while (NumLocations--) {
6313 assert(Idx < Record.size() &&
6314 "Invalid data, missing pragma diagnostic states");
6315 SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
6316 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
6317 assert(IDAndOffset.first.isValid() && "invalid FileID for transition");
6318 assert(IDAndOffset.second == 0 && "not a start location for a FileID");
6319 unsigned Transitions = Record[Idx++];
6320
6321 // Note that we don't need to set up Parent/ParentOffset here, because
6322 // we won't be changing the diagnostic state within imported FileIDs
6323 // (other than perhaps appending to the main source file, which has no
6324 // parent).
6325 auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
6326 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
6327 for (unsigned I = 0; I != Transitions; ++I) {
6328 unsigned Offset = Record[Idx++];
6329 auto *State =
6330 ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
6331 F.StateTransitions.push_back({State, Offset});
6332 }
6333 }
6334
6335 // Read the final state.
6336 assert(Idx < Record.size() &&
6337 "Invalid data, missing final pragma diagnostic state");
6338 SourceLocation CurStateLoc =
6339 ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
6340 auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
6341
6342 if (!F.isModule()) {
6343 Diag.DiagStatesByLoc.CurDiagState = CurState;
6344 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
6345
6346 // Preserve the property that the imaginary root file describes the
6347 // current state.
6348 FileID NullFile;
6349 auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
6350 if (T.empty())
6351 T.push_back({CurState, 0});
6352 else
6353 T[0].State = CurState;
6354 }
6355
6356 // Don't try to read these mappings again.
6357 Record.clear();
6358 }
6359 }
6360
6361 /// Get the correct cursor and offset for loading a type.
TypeCursorForIndex(unsigned Index)6362 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
6363 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
6364 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
6365 ModuleFile *M = I->second;
6366 return RecordLocation(
6367 M, M->TypeOffsets[Index - M->BaseTypeIndex].getBitOffset() +
6368 M->DeclsBlockStartOffset);
6369 }
6370
getTypeClassForCode(TypeCode code)6371 static llvm::Optional<Type::TypeClass> getTypeClassForCode(TypeCode code) {
6372 switch (code) {
6373 #define TYPE_BIT_CODE(CLASS_ID, CODE_ID, CODE_VALUE) \
6374 case TYPE_##CODE_ID: return Type::CLASS_ID;
6375 #include "clang/Serialization/TypeBitCodes.def"
6376 default: return llvm::None;
6377 }
6378 }
6379
6380 /// Read and return the type with the given index..
6381 ///
6382 /// The index is the type ID, shifted and minus the number of predefs. This
6383 /// routine actually reads the record corresponding to the type at the given
6384 /// location. It is a helper routine for GetType, which deals with reading type
6385 /// IDs.
readTypeRecord(unsigned Index)6386 QualType ASTReader::readTypeRecord(unsigned Index) {
6387 assert(ContextObj && "reading type with no AST context");
6388 ASTContext &Context = *ContextObj;
6389 RecordLocation Loc = TypeCursorForIndex(Index);
6390 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
6391
6392 // Keep track of where we are in the stream, then jump back there
6393 // after reading this type.
6394 SavedStreamPosition SavedPosition(DeclsCursor);
6395
6396 ReadingKindTracker ReadingKind(Read_Type, *this);
6397
6398 // Note that we are loading a type record.
6399 Deserializing AType(this);
6400
6401 if (llvm::Error Err = DeclsCursor.JumpToBit(Loc.Offset)) {
6402 Error(std::move(Err));
6403 return QualType();
6404 }
6405 Expected<unsigned> RawCode = DeclsCursor.ReadCode();
6406 if (!RawCode) {
6407 Error(RawCode.takeError());
6408 return QualType();
6409 }
6410
6411 ASTRecordReader Record(*this, *Loc.F);
6412 Expected<unsigned> Code = Record.readRecord(DeclsCursor, RawCode.get());
6413 if (!Code) {
6414 Error(Code.takeError());
6415 return QualType();
6416 }
6417 if (Code.get() == TYPE_EXT_QUAL) {
6418 QualType baseType = Record.readQualType();
6419 Qualifiers quals = Record.readQualifiers();
6420 return Context.getQualifiedType(baseType, quals);
6421 }
6422
6423 auto maybeClass = getTypeClassForCode((TypeCode) Code.get());
6424 if (!maybeClass) {
6425 Error("Unexpected code for type");
6426 return QualType();
6427 }
6428
6429 serialization::AbstractTypeReader<ASTRecordReader> TypeReader(Record);
6430 return TypeReader.read(*maybeClass);
6431 }
6432
6433 namespace clang {
6434
6435 class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6436 ASTRecordReader &Reader;
6437
readSourceLocation()6438 SourceLocation readSourceLocation() {
6439 return Reader.readSourceLocation();
6440 }
6441
GetTypeSourceInfo()6442 TypeSourceInfo *GetTypeSourceInfo() {
6443 return Reader.readTypeSourceInfo();
6444 }
6445
ReadNestedNameSpecifierLoc()6446 NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6447 return Reader.readNestedNameSpecifierLoc();
6448 }
6449
ReadAttr()6450 Attr *ReadAttr() {
6451 return Reader.readAttr();
6452 }
6453
6454 public:
TypeLocReader(ASTRecordReader & Reader)6455 TypeLocReader(ASTRecordReader &Reader) : Reader(Reader) {}
6456
6457 // We want compile-time assurance that we've enumerated all of
6458 // these, so unfortunately we have to declare them first, then
6459 // define them out-of-line.
6460 #define ABSTRACT_TYPELOC(CLASS, PARENT)
6461 #define TYPELOC(CLASS, PARENT) \
6462 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6463 #include "clang/AST/TypeLocNodes.def"
6464
6465 void VisitFunctionTypeLoc(FunctionTypeLoc);
6466 void VisitArrayTypeLoc(ArrayTypeLoc);
6467 };
6468
6469 } // namespace clang
6470
VisitQualifiedTypeLoc(QualifiedTypeLoc TL)6471 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6472 // nothing to do
6473 }
6474
VisitBuiltinTypeLoc(BuiltinTypeLoc TL)6475 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6476 TL.setBuiltinLoc(readSourceLocation());
6477 if (TL.needsExtraLocalData()) {
6478 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Reader.readInt()));
6479 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Reader.readInt()));
6480 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Reader.readInt()));
6481 TL.setModeAttr(Reader.readInt());
6482 }
6483 }
6484
VisitComplexTypeLoc(ComplexTypeLoc TL)6485 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6486 TL.setNameLoc(readSourceLocation());
6487 }
6488
VisitPointerTypeLoc(PointerTypeLoc TL)6489 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6490 TL.setStarLoc(readSourceLocation());
6491 }
6492
VisitDecayedTypeLoc(DecayedTypeLoc TL)6493 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6494 // nothing to do
6495 }
6496
VisitAdjustedTypeLoc(AdjustedTypeLoc TL)6497 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6498 // nothing to do
6499 }
6500
VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL)6501 void TypeLocReader::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6502 TL.setExpansionLoc(readSourceLocation());
6503 }
6504
VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL)6505 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6506 TL.setCaretLoc(readSourceLocation());
6507 }
6508
VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL)6509 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6510 TL.setAmpLoc(readSourceLocation());
6511 }
6512
VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL)6513 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6514 TL.setAmpAmpLoc(readSourceLocation());
6515 }
6516
VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL)6517 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6518 TL.setStarLoc(readSourceLocation());
6519 TL.setClassTInfo(GetTypeSourceInfo());
6520 }
6521
VisitArrayTypeLoc(ArrayTypeLoc TL)6522 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6523 TL.setLBracketLoc(readSourceLocation());
6524 TL.setRBracketLoc(readSourceLocation());
6525 if (Reader.readBool())
6526 TL.setSizeExpr(Reader.readExpr());
6527 else
6528 TL.setSizeExpr(nullptr);
6529 }
6530
VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL)6531 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6532 VisitArrayTypeLoc(TL);
6533 }
6534
VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL)6535 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6536 VisitArrayTypeLoc(TL);
6537 }
6538
VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL)6539 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6540 VisitArrayTypeLoc(TL);
6541 }
6542
VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL)6543 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6544 DependentSizedArrayTypeLoc TL) {
6545 VisitArrayTypeLoc(TL);
6546 }
6547
VisitDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc TL)6548 void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6549 DependentAddressSpaceTypeLoc TL) {
6550
6551 TL.setAttrNameLoc(readSourceLocation());
6552 TL.setAttrOperandParensRange(Reader.readSourceRange());
6553 TL.setAttrExprOperand(Reader.readExpr());
6554 }
6555
VisitDependentPointerTypeLoc(DependentPointerTypeLoc TL)6556 void TypeLocReader::VisitDependentPointerTypeLoc(
6557 DependentPointerTypeLoc TL) {
6558 TL.setQualifierLoc(readSourceLocation());
6559 }
6560
VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL)6561 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6562 DependentSizedExtVectorTypeLoc TL) {
6563 TL.setNameLoc(readSourceLocation());
6564 }
6565
VisitVectorTypeLoc(VectorTypeLoc TL)6566 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6567 TL.setNameLoc(readSourceLocation());
6568 }
6569
VisitDependentVectorTypeLoc(DependentVectorTypeLoc TL)6570 void TypeLocReader::VisitDependentVectorTypeLoc(
6571 DependentVectorTypeLoc TL) {
6572 TL.setNameLoc(readSourceLocation());
6573 }
6574
VisitExtVectorTypeLoc(ExtVectorTypeLoc TL)6575 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6576 TL.setNameLoc(readSourceLocation());
6577 }
6578
VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL)6579 void TypeLocReader::VisitConstantMatrixTypeLoc(ConstantMatrixTypeLoc TL) {
6580 TL.setAttrNameLoc(readSourceLocation());
6581 TL.setAttrOperandParensRange(Reader.readSourceRange());
6582 TL.setAttrRowOperand(Reader.readExpr());
6583 TL.setAttrColumnOperand(Reader.readExpr());
6584 }
6585
VisitDependentSizedMatrixTypeLoc(DependentSizedMatrixTypeLoc TL)6586 void TypeLocReader::VisitDependentSizedMatrixTypeLoc(
6587 DependentSizedMatrixTypeLoc TL) {
6588 TL.setAttrNameLoc(readSourceLocation());
6589 TL.setAttrOperandParensRange(Reader.readSourceRange());
6590 TL.setAttrRowOperand(Reader.readExpr());
6591 TL.setAttrColumnOperand(Reader.readExpr());
6592 }
6593
VisitFunctionTypeLoc(FunctionTypeLoc TL)6594 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6595 TL.setLocalRangeBegin(readSourceLocation());
6596 TL.setLParenLoc(readSourceLocation());
6597 TL.setRParenLoc(readSourceLocation());
6598 TL.setExceptionSpecRange(Reader.readSourceRange());
6599 TL.setLocalRangeEnd(readSourceLocation());
6600 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6601 TL.setParam(i, Reader.readDeclAs<ParmVarDecl>());
6602 }
6603 }
6604
VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL)6605 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6606 VisitFunctionTypeLoc(TL);
6607 }
6608
VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL)6609 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6610 VisitFunctionTypeLoc(TL);
6611 }
6612
VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL)6613 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6614 TL.setNameLoc(readSourceLocation());
6615 }
6616
VisitTypedefTypeLoc(TypedefTypeLoc TL)6617 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6618 TL.setNameLoc(readSourceLocation());
6619 }
6620
VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL)6621 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6622 TL.setTypeofLoc(readSourceLocation());
6623 TL.setLParenLoc(readSourceLocation());
6624 TL.setRParenLoc(readSourceLocation());
6625 }
6626
VisitTypeOfTypeLoc(TypeOfTypeLoc TL)6627 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6628 TL.setTypeofLoc(readSourceLocation());
6629 TL.setLParenLoc(readSourceLocation());
6630 TL.setRParenLoc(readSourceLocation());
6631 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6632 }
6633
VisitDecltypeTypeLoc(DecltypeTypeLoc TL)6634 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6635 TL.setNameLoc(readSourceLocation());
6636 }
6637
VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL)6638 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6639 TL.setKWLoc(readSourceLocation());
6640 TL.setLParenLoc(readSourceLocation());
6641 TL.setRParenLoc(readSourceLocation());
6642 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6643 }
6644
VisitAutoTypeLoc(AutoTypeLoc TL)6645 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6646 TL.setNameLoc(readSourceLocation());
6647 if (Reader.readBool()) {
6648 TL.setNestedNameSpecifierLoc(ReadNestedNameSpecifierLoc());
6649 TL.setTemplateKWLoc(readSourceLocation());
6650 TL.setConceptNameLoc(readSourceLocation());
6651 TL.setFoundDecl(Reader.readDeclAs<NamedDecl>());
6652 TL.setLAngleLoc(readSourceLocation());
6653 TL.setRAngleLoc(readSourceLocation());
6654 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6655 TL.setArgLocInfo(i, Reader.readTemplateArgumentLocInfo(
6656 TL.getTypePtr()->getArg(i).getKind()));
6657 }
6658 }
6659
VisitDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL)6660 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6661 DeducedTemplateSpecializationTypeLoc TL) {
6662 TL.setTemplateNameLoc(readSourceLocation());
6663 }
6664
VisitRecordTypeLoc(RecordTypeLoc TL)6665 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6666 TL.setNameLoc(readSourceLocation());
6667 }
6668
VisitEnumTypeLoc(EnumTypeLoc TL)6669 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6670 TL.setNameLoc(readSourceLocation());
6671 }
6672
VisitAttributedTypeLoc(AttributedTypeLoc TL)6673 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6674 TL.setAttr(ReadAttr());
6675 }
6676
VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL)6677 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6678 TL.setNameLoc(readSourceLocation());
6679 }
6680
VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL)6681 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6682 SubstTemplateTypeParmTypeLoc TL) {
6683 TL.setNameLoc(readSourceLocation());
6684 }
6685
VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL)6686 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6687 SubstTemplateTypeParmPackTypeLoc TL) {
6688 TL.setNameLoc(readSourceLocation());
6689 }
6690
VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL)6691 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6692 TemplateSpecializationTypeLoc TL) {
6693 TL.setTemplateKeywordLoc(readSourceLocation());
6694 TL.setTemplateNameLoc(readSourceLocation());
6695 TL.setLAngleLoc(readSourceLocation());
6696 TL.setRAngleLoc(readSourceLocation());
6697 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6698 TL.setArgLocInfo(
6699 i,
6700 Reader.readTemplateArgumentLocInfo(
6701 TL.getTypePtr()->getArg(i).getKind()));
6702 }
6703
VisitParenTypeLoc(ParenTypeLoc TL)6704 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6705 TL.setLParenLoc(readSourceLocation());
6706 TL.setRParenLoc(readSourceLocation());
6707 }
6708
VisitElaboratedTypeLoc(ElaboratedTypeLoc TL)6709 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6710 TL.setElaboratedKeywordLoc(readSourceLocation());
6711 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6712 }
6713
VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL)6714 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6715 TL.setNameLoc(readSourceLocation());
6716 }
6717
VisitDependentNameTypeLoc(DependentNameTypeLoc TL)6718 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6719 TL.setElaboratedKeywordLoc(readSourceLocation());
6720 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6721 TL.setNameLoc(readSourceLocation());
6722 }
6723
VisitDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL)6724 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6725 DependentTemplateSpecializationTypeLoc TL) {
6726 TL.setElaboratedKeywordLoc(readSourceLocation());
6727 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6728 TL.setTemplateKeywordLoc(readSourceLocation());
6729 TL.setTemplateNameLoc(readSourceLocation());
6730 TL.setLAngleLoc(readSourceLocation());
6731 TL.setRAngleLoc(readSourceLocation());
6732 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6733 TL.setArgLocInfo(
6734 I,
6735 Reader.readTemplateArgumentLocInfo(
6736 TL.getTypePtr()->getArg(I).getKind()));
6737 }
6738
VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL)6739 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6740 TL.setEllipsisLoc(readSourceLocation());
6741 }
6742
VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL)6743 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6744 TL.setNameLoc(readSourceLocation());
6745 }
6746
VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL)6747 void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6748 if (TL.getNumProtocols()) {
6749 TL.setProtocolLAngleLoc(readSourceLocation());
6750 TL.setProtocolRAngleLoc(readSourceLocation());
6751 }
6752 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6753 TL.setProtocolLoc(i, readSourceLocation());
6754 }
6755
VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL)6756 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6757 TL.setHasBaseTypeAsWritten(Reader.readBool());
6758 TL.setTypeArgsLAngleLoc(readSourceLocation());
6759 TL.setTypeArgsRAngleLoc(readSourceLocation());
6760 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6761 TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6762 TL.setProtocolLAngleLoc(readSourceLocation());
6763 TL.setProtocolRAngleLoc(readSourceLocation());
6764 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6765 TL.setProtocolLoc(i, readSourceLocation());
6766 }
6767
VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL)6768 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6769 TL.setStarLoc(readSourceLocation());
6770 }
6771
VisitAtomicTypeLoc(AtomicTypeLoc TL)6772 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6773 TL.setKWLoc(readSourceLocation());
6774 TL.setLParenLoc(readSourceLocation());
6775 TL.setRParenLoc(readSourceLocation());
6776 }
6777
VisitPipeTypeLoc(PipeTypeLoc TL)6778 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6779 TL.setKWLoc(readSourceLocation());
6780 }
6781
VisitExtIntTypeLoc(clang::ExtIntTypeLoc TL)6782 void TypeLocReader::VisitExtIntTypeLoc(clang::ExtIntTypeLoc TL) {
6783 TL.setNameLoc(readSourceLocation());
6784 }
VisitDependentExtIntTypeLoc(clang::DependentExtIntTypeLoc TL)6785 void TypeLocReader::VisitDependentExtIntTypeLoc(
6786 clang::DependentExtIntTypeLoc TL) {
6787 TL.setNameLoc(readSourceLocation());
6788 }
6789
6790
readTypeLoc(TypeLoc TL)6791 void ASTRecordReader::readTypeLoc(TypeLoc TL) {
6792 TypeLocReader TLR(*this);
6793 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6794 TLR.Visit(TL);
6795 }
6796
readTypeSourceInfo()6797 TypeSourceInfo *ASTRecordReader::readTypeSourceInfo() {
6798 QualType InfoTy = readType();
6799 if (InfoTy.isNull())
6800 return nullptr;
6801
6802 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6803 readTypeLoc(TInfo->getTypeLoc());
6804 return TInfo;
6805 }
6806
GetType(TypeID ID)6807 QualType ASTReader::GetType(TypeID ID) {
6808 assert(ContextObj && "reading type with no AST context");
6809 ASTContext &Context = *ContextObj;
6810
6811 unsigned FastQuals = ID & Qualifiers::FastMask;
6812 unsigned Index = ID >> Qualifiers::FastWidth;
6813
6814 if (Index < NUM_PREDEF_TYPE_IDS) {
6815 QualType T;
6816 switch ((PredefinedTypeIDs)Index) {
6817 case PREDEF_TYPE_NULL_ID:
6818 return QualType();
6819 case PREDEF_TYPE_VOID_ID:
6820 T = Context.VoidTy;
6821 break;
6822 case PREDEF_TYPE_BOOL_ID:
6823 T = Context.BoolTy;
6824 break;
6825 case PREDEF_TYPE_CHAR_U_ID:
6826 case PREDEF_TYPE_CHAR_S_ID:
6827 // FIXME: Check that the signedness of CharTy is correct!
6828 T = Context.CharTy;
6829 break;
6830 case PREDEF_TYPE_UCHAR_ID:
6831 T = Context.UnsignedCharTy;
6832 break;
6833 case PREDEF_TYPE_USHORT_ID:
6834 T = Context.UnsignedShortTy;
6835 break;
6836 case PREDEF_TYPE_UINT_ID:
6837 T = Context.UnsignedIntTy;
6838 break;
6839 case PREDEF_TYPE_ULONG_ID:
6840 T = Context.UnsignedLongTy;
6841 break;
6842 case PREDEF_TYPE_ULONGLONG_ID:
6843 T = Context.UnsignedLongLongTy;
6844 break;
6845 case PREDEF_TYPE_UINT128_ID:
6846 T = Context.UnsignedInt128Ty;
6847 break;
6848 case PREDEF_TYPE_UINTCAP_ID:
6849 T = Context.UnsignedIntCapTy;
6850 break;
6851 case PREDEF_TYPE_SCHAR_ID:
6852 T = Context.SignedCharTy;
6853 break;
6854 case PREDEF_TYPE_WCHAR_ID:
6855 T = Context.WCharTy;
6856 break;
6857 case PREDEF_TYPE_SHORT_ID:
6858 T = Context.ShortTy;
6859 break;
6860 case PREDEF_TYPE_INT_ID:
6861 T = Context.IntTy;
6862 break;
6863 case PREDEF_TYPE_LONG_ID:
6864 T = Context.LongTy;
6865 break;
6866 case PREDEF_TYPE_LONGLONG_ID:
6867 T = Context.LongLongTy;
6868 break;
6869 case PREDEF_TYPE_INT128_ID:
6870 T = Context.Int128Ty;
6871 break;
6872 case PREDEF_TYPE_INTCAP_ID:
6873 T = Context.IntCapTy;
6874 break;
6875 case PREDEF_TYPE_BFLOAT16_ID:
6876 T = Context.BFloat16Ty;
6877 break;
6878 case PREDEF_TYPE_HALF_ID:
6879 T = Context.HalfTy;
6880 break;
6881 case PREDEF_TYPE_FLOAT_ID:
6882 T = Context.FloatTy;
6883 break;
6884 case PREDEF_TYPE_DOUBLE_ID:
6885 T = Context.DoubleTy;
6886 break;
6887 case PREDEF_TYPE_LONGDOUBLE_ID:
6888 T = Context.LongDoubleTy;
6889 break;
6890 case PREDEF_TYPE_SHORT_ACCUM_ID:
6891 T = Context.ShortAccumTy;
6892 break;
6893 case PREDEF_TYPE_ACCUM_ID:
6894 T = Context.AccumTy;
6895 break;
6896 case PREDEF_TYPE_LONG_ACCUM_ID:
6897 T = Context.LongAccumTy;
6898 break;
6899 case PREDEF_TYPE_USHORT_ACCUM_ID:
6900 T = Context.UnsignedShortAccumTy;
6901 break;
6902 case PREDEF_TYPE_UACCUM_ID:
6903 T = Context.UnsignedAccumTy;
6904 break;
6905 case PREDEF_TYPE_ULONG_ACCUM_ID:
6906 T = Context.UnsignedLongAccumTy;
6907 break;
6908 case PREDEF_TYPE_SHORT_FRACT_ID:
6909 T = Context.ShortFractTy;
6910 break;
6911 case PREDEF_TYPE_FRACT_ID:
6912 T = Context.FractTy;
6913 break;
6914 case PREDEF_TYPE_LONG_FRACT_ID:
6915 T = Context.LongFractTy;
6916 break;
6917 case PREDEF_TYPE_USHORT_FRACT_ID:
6918 T = Context.UnsignedShortFractTy;
6919 break;
6920 case PREDEF_TYPE_UFRACT_ID:
6921 T = Context.UnsignedFractTy;
6922 break;
6923 case PREDEF_TYPE_ULONG_FRACT_ID:
6924 T = Context.UnsignedLongFractTy;
6925 break;
6926 case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
6927 T = Context.SatShortAccumTy;
6928 break;
6929 case PREDEF_TYPE_SAT_ACCUM_ID:
6930 T = Context.SatAccumTy;
6931 break;
6932 case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
6933 T = Context.SatLongAccumTy;
6934 break;
6935 case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
6936 T = Context.SatUnsignedShortAccumTy;
6937 break;
6938 case PREDEF_TYPE_SAT_UACCUM_ID:
6939 T = Context.SatUnsignedAccumTy;
6940 break;
6941 case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
6942 T = Context.SatUnsignedLongAccumTy;
6943 break;
6944 case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
6945 T = Context.SatShortFractTy;
6946 break;
6947 case PREDEF_TYPE_SAT_FRACT_ID:
6948 T = Context.SatFractTy;
6949 break;
6950 case PREDEF_TYPE_SAT_LONG_FRACT_ID:
6951 T = Context.SatLongFractTy;
6952 break;
6953 case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
6954 T = Context.SatUnsignedShortFractTy;
6955 break;
6956 case PREDEF_TYPE_SAT_UFRACT_ID:
6957 T = Context.SatUnsignedFractTy;
6958 break;
6959 case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
6960 T = Context.SatUnsignedLongFractTy;
6961 break;
6962 case PREDEF_TYPE_FLOAT16_ID:
6963 T = Context.Float16Ty;
6964 break;
6965 case PREDEF_TYPE_FLOAT128_ID:
6966 T = Context.Float128Ty;
6967 break;
6968 case PREDEF_TYPE_OVERLOAD_ID:
6969 T = Context.OverloadTy;
6970 break;
6971 case PREDEF_TYPE_BOUND_MEMBER:
6972 T = Context.BoundMemberTy;
6973 break;
6974 case PREDEF_TYPE_PSEUDO_OBJECT:
6975 T = Context.PseudoObjectTy;
6976 break;
6977 case PREDEF_TYPE_DEPENDENT_ID:
6978 T = Context.DependentTy;
6979 break;
6980 case PREDEF_TYPE_UNKNOWN_ANY:
6981 T = Context.UnknownAnyTy;
6982 break;
6983 case PREDEF_TYPE_NULLPTR_ID:
6984 T = Context.NullPtrTy;
6985 break;
6986 case PREDEF_TYPE_CHAR8_ID:
6987 T = Context.Char8Ty;
6988 break;
6989 case PREDEF_TYPE_CHAR16_ID:
6990 T = Context.Char16Ty;
6991 break;
6992 case PREDEF_TYPE_CHAR32_ID:
6993 T = Context.Char32Ty;
6994 break;
6995 case PREDEF_TYPE_OBJC_ID:
6996 T = Context.ObjCBuiltinIdTy;
6997 break;
6998 case PREDEF_TYPE_OBJC_CLASS:
6999 T = Context.ObjCBuiltinClassTy;
7000 break;
7001 case PREDEF_TYPE_OBJC_SEL:
7002 T = Context.ObjCBuiltinSelTy;
7003 break;
7004 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7005 case PREDEF_TYPE_##Id##_ID: \
7006 T = Context.SingletonId; \
7007 break;
7008 #include "clang/Basic/OpenCLImageTypes.def"
7009 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7010 case PREDEF_TYPE_##Id##_ID: \
7011 T = Context.Id##Ty; \
7012 break;
7013 #include "clang/Basic/OpenCLExtensionTypes.def"
7014 case PREDEF_TYPE_SAMPLER_ID:
7015 T = Context.OCLSamplerTy;
7016 break;
7017 case PREDEF_TYPE_EVENT_ID:
7018 T = Context.OCLEventTy;
7019 break;
7020 case PREDEF_TYPE_CLK_EVENT_ID:
7021 T = Context.OCLClkEventTy;
7022 break;
7023 case PREDEF_TYPE_QUEUE_ID:
7024 T = Context.OCLQueueTy;
7025 break;
7026 case PREDEF_TYPE_RESERVE_ID_ID:
7027 T = Context.OCLReserveIDTy;
7028 break;
7029 case PREDEF_TYPE_AUTO_DEDUCT:
7030 T = Context.getAutoDeductType();
7031 break;
7032 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
7033 T = Context.getAutoRRefDeductType();
7034 break;
7035 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
7036 T = Context.ARCUnbridgedCastTy;
7037 break;
7038 case PREDEF_TYPE_BUILTIN_FN:
7039 T = Context.BuiltinFnTy;
7040 break;
7041 case PREDEF_TYPE_INCOMPLETE_MATRIX_IDX:
7042 T = Context.IncompleteMatrixIdxTy;
7043 break;
7044 case PREDEF_TYPE_OMP_ARRAY_SECTION:
7045 T = Context.OMPArraySectionTy;
7046 break;
7047 case PREDEF_TYPE_OMP_ARRAY_SHAPING:
7048 T = Context.OMPArraySectionTy;
7049 break;
7050 case PREDEF_TYPE_OMP_ITERATOR:
7051 T = Context.OMPIteratorTy;
7052 break;
7053 #define SVE_TYPE(Name, Id, SingletonId) \
7054 case PREDEF_TYPE_##Id##_ID: \
7055 T = Context.SingletonId; \
7056 break;
7057 #include "clang/Basic/AArch64SVEACLETypes.def"
7058 }
7059
7060 assert(!T.isNull() && "Unknown predefined type");
7061 return T.withFastQualifiers(FastQuals);
7062 }
7063
7064 Index -= NUM_PREDEF_TYPE_IDS;
7065 assert(Index < TypesLoaded.size() && "Type index out-of-range");
7066 if (TypesLoaded[Index].isNull()) {
7067 TypesLoaded[Index] = readTypeRecord(Index);
7068 if (TypesLoaded[Index].isNull())
7069 return QualType();
7070
7071 TypesLoaded[Index]->setFromAST();
7072 if (DeserializationListener)
7073 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7074 TypesLoaded[Index]);
7075 }
7076
7077 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7078 }
7079
getLocalType(ModuleFile & F,unsigned LocalID)7080 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7081 return GetType(getGlobalTypeID(F, LocalID));
7082 }
7083
7084 serialization::TypeID
getGlobalTypeID(ModuleFile & F,unsigned LocalID) const7085 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7086 unsigned FastQuals = LocalID & Qualifiers::FastMask;
7087 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7088
7089 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7090 return LocalID;
7091
7092 if (!F.ModuleOffsetMap.empty())
7093 ReadModuleOffsetMap(F);
7094
7095 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7096 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7097 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
7098
7099 unsigned GlobalIndex = LocalIndex + I->second;
7100 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7101 }
7102
7103 TemplateArgumentLocInfo
readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind)7104 ASTRecordReader::readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind) {
7105 switch (Kind) {
7106 case TemplateArgument::Expression:
7107 return readExpr();
7108 case TemplateArgument::Type:
7109 return readTypeSourceInfo();
7110 case TemplateArgument::Template: {
7111 NestedNameSpecifierLoc QualifierLoc =
7112 readNestedNameSpecifierLoc();
7113 SourceLocation TemplateNameLoc = readSourceLocation();
7114 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7115 SourceLocation());
7116 }
7117 case TemplateArgument::TemplateExpansion: {
7118 NestedNameSpecifierLoc QualifierLoc = readNestedNameSpecifierLoc();
7119 SourceLocation TemplateNameLoc = readSourceLocation();
7120 SourceLocation EllipsisLoc = readSourceLocation();
7121 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7122 EllipsisLoc);
7123 }
7124 case TemplateArgument::Null:
7125 case TemplateArgument::Integral:
7126 case TemplateArgument::Declaration:
7127 case TemplateArgument::NullPtr:
7128 case TemplateArgument::Pack:
7129 // FIXME: Is this right?
7130 return TemplateArgumentLocInfo();
7131 }
7132 llvm_unreachable("unexpected template argument loc");
7133 }
7134
readTemplateArgumentLoc()7135 TemplateArgumentLoc ASTRecordReader::readTemplateArgumentLoc() {
7136 TemplateArgument Arg = readTemplateArgument();
7137
7138 if (Arg.getKind() == TemplateArgument::Expression) {
7139 if (readBool()) // bool InfoHasSameExpr.
7140 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7141 }
7142 return TemplateArgumentLoc(Arg, readTemplateArgumentLocInfo(Arg.getKind()));
7143 }
7144
7145 const ASTTemplateArgumentListInfo *
readASTTemplateArgumentListInfo()7146 ASTRecordReader::readASTTemplateArgumentListInfo() {
7147 SourceLocation LAngleLoc = readSourceLocation();
7148 SourceLocation RAngleLoc = readSourceLocation();
7149 unsigned NumArgsAsWritten = readInt();
7150 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7151 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7152 TemplArgsInfo.addArgument(readTemplateArgumentLoc());
7153 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7154 }
7155
GetExternalDecl(uint32_t ID)7156 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7157 return GetDecl(ID);
7158 }
7159
CompleteRedeclChain(const Decl * D)7160 void ASTReader::CompleteRedeclChain(const Decl *D) {
7161 if (NumCurrentElementsDeserializing) {
7162 // We arrange to not care about the complete redeclaration chain while we're
7163 // deserializing. Just remember that the AST has marked this one as complete
7164 // but that it's not actually complete yet, so we know we still need to
7165 // complete it later.
7166 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7167 return;
7168 }
7169
7170 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7171
7172 // If this is a named declaration, complete it by looking it up
7173 // within its context.
7174 //
7175 // FIXME: Merging a function definition should merge
7176 // all mergeable entities within it.
7177 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7178 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7179 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7180 if (!getContext().getLangOpts().CPlusPlus &&
7181 isa<TranslationUnitDecl>(DC)) {
7182 // Outside of C++, we don't have a lookup table for the TU, so update
7183 // the identifier instead. (For C++ modules, we don't store decls
7184 // in the serialized identifier table, so we do the lookup in the TU.)
7185 auto *II = Name.getAsIdentifierInfo();
7186 assert(II && "non-identifier name in C?");
7187 if (II->isOutOfDate())
7188 updateOutOfDateIdentifier(*II);
7189 } else
7190 DC->lookup(Name);
7191 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7192 // Find all declarations of this kind from the relevant context.
7193 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7194 auto *DC = cast<DeclContext>(DCDecl);
7195 SmallVector<Decl*, 8> Decls;
7196 FindExternalLexicalDecls(
7197 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7198 }
7199 }
7200 }
7201
7202 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7203 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7204 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7205 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7206 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7207 if (auto *Template = FD->getPrimaryTemplate())
7208 Template->LoadLazySpecializations();
7209 }
7210 }
7211
7212 CXXCtorInitializer **
GetExternalCXXCtorInitializers(uint64_t Offset)7213 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7214 RecordLocation Loc = getLocalBitOffset(Offset);
7215 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7216 SavedStreamPosition SavedPosition(Cursor);
7217 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7218 Error(std::move(Err));
7219 return nullptr;
7220 }
7221 ReadingKindTracker ReadingKind(Read_Decl, *this);
7222
7223 Expected<unsigned> MaybeCode = Cursor.ReadCode();
7224 if (!MaybeCode) {
7225 Error(MaybeCode.takeError());
7226 return nullptr;
7227 }
7228 unsigned Code = MaybeCode.get();
7229
7230 ASTRecordReader Record(*this, *Loc.F);
7231 Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code);
7232 if (!MaybeRecCode) {
7233 Error(MaybeRecCode.takeError());
7234 return nullptr;
7235 }
7236 if (MaybeRecCode.get() != DECL_CXX_CTOR_INITIALIZERS) {
7237 Error("malformed AST file: missing C++ ctor initializers");
7238 return nullptr;
7239 }
7240
7241 return Record.readCXXCtorInitializers();
7242 }
7243
GetExternalCXXBaseSpecifiers(uint64_t Offset)7244 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7245 assert(ContextObj && "reading base specifiers with no AST context");
7246 ASTContext &Context = *ContextObj;
7247
7248 RecordLocation Loc = getLocalBitOffset(Offset);
7249 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7250 SavedStreamPosition SavedPosition(Cursor);
7251 if (llvm::Error Err = Cursor.JumpToBit(Loc.Offset)) {
7252 Error(std::move(Err));
7253 return nullptr;
7254 }
7255 ReadingKindTracker ReadingKind(Read_Decl, *this);
7256
7257 Expected<unsigned> MaybeCode = Cursor.ReadCode();
7258 if (!MaybeCode) {
7259 Error(MaybeCode.takeError());
7260 return nullptr;
7261 }
7262 unsigned Code = MaybeCode.get();
7263
7264 ASTRecordReader Record(*this, *Loc.F);
7265 Expected<unsigned> MaybeRecCode = Record.readRecord(Cursor, Code);
7266 if (!MaybeRecCode) {
7267 Error(MaybeCode.takeError());
7268 return nullptr;
7269 }
7270 unsigned RecCode = MaybeRecCode.get();
7271
7272 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7273 Error("malformed AST file: missing C++ base specifiers");
7274 return nullptr;
7275 }
7276
7277 unsigned NumBases = Record.readInt();
7278 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7279 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7280 for (unsigned I = 0; I != NumBases; ++I)
7281 Bases[I] = Record.readCXXBaseSpecifier();
7282 return Bases;
7283 }
7284
7285 serialization::DeclID
getGlobalDeclID(ModuleFile & F,LocalDeclID LocalID) const7286 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7287 if (LocalID < NUM_PREDEF_DECL_IDS)
7288 return LocalID;
7289
7290 if (!F.ModuleOffsetMap.empty())
7291 ReadModuleOffsetMap(F);
7292
7293 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7294 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7295 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
7296
7297 return LocalID + I->second;
7298 }
7299
isDeclIDFromModule(serialization::GlobalDeclID ID,ModuleFile & M) const7300 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7301 ModuleFile &M) const {
7302 // Predefined decls aren't from any module.
7303 if (ID < NUM_PREDEF_DECL_IDS)
7304 return false;
7305
7306 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7307 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7308 }
7309
getOwningModuleFile(const Decl * D)7310 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7311 if (!D->isFromASTFile())
7312 return nullptr;
7313 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7314 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7315 return I->second;
7316 }
7317
getSourceLocationForDeclID(GlobalDeclID ID)7318 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7319 if (ID < NUM_PREDEF_DECL_IDS)
7320 return SourceLocation();
7321
7322 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7323
7324 if (Index > DeclsLoaded.size()) {
7325 Error("declaration ID out-of-range for AST file");
7326 return SourceLocation();
7327 }
7328
7329 if (Decl *D = DeclsLoaded[Index])
7330 return D->getLocation();
7331
7332 SourceLocation Loc;
7333 DeclCursorForID(ID, Loc);
7334 return Loc;
7335 }
7336
getPredefinedDecl(ASTContext & Context,PredefinedDeclIDs ID)7337 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7338 switch (ID) {
7339 case PREDEF_DECL_NULL_ID:
7340 return nullptr;
7341
7342 case PREDEF_DECL_TRANSLATION_UNIT_ID:
7343 return Context.getTranslationUnitDecl();
7344
7345 case PREDEF_DECL_OBJC_ID_ID:
7346 return Context.getObjCIdDecl();
7347
7348 case PREDEF_DECL_OBJC_SEL_ID:
7349 return Context.getObjCSelDecl();
7350
7351 case PREDEF_DECL_OBJC_CLASS_ID:
7352 return Context.getObjCClassDecl();
7353
7354 case PREDEF_DECL_OBJC_PROTOCOL_ID:
7355 return Context.getObjCProtocolDecl();
7356
7357 case PREDEF_DECL_INT_128_ID:
7358 return Context.getInt128Decl();
7359
7360 case PREDEF_DECL_UNSIGNED_INT_128_ID:
7361 return Context.getUInt128Decl();
7362
7363 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7364 return Context.getObjCInstanceTypeDecl();
7365
7366 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7367 return Context.getBuiltinVaListDecl();
7368
7369 case PREDEF_DECL_VA_LIST_TAG:
7370 return Context.getVaListTagDecl();
7371
7372 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7373 return Context.getBuiltinMSVaListDecl();
7374
7375 case PREDEF_DECL_BUILTIN_MS_GUID_ID:
7376 return Context.getMSGuidTagDecl();
7377
7378 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7379 return Context.getExternCContextDecl();
7380
7381 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7382 return Context.getMakeIntegerSeqDecl();
7383
7384 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7385 return Context.getCFConstantStringDecl();
7386
7387 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7388 return Context.getCFConstantStringTagDecl();
7389
7390 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7391 return Context.getTypePackElementDecl();
7392 }
7393 llvm_unreachable("PredefinedDeclIDs unknown enum value");
7394 }
7395
GetExistingDecl(DeclID ID)7396 Decl *ASTReader::GetExistingDecl(DeclID ID) {
7397 assert(ContextObj && "reading decl with no AST context");
7398 if (ID < NUM_PREDEF_DECL_IDS) {
7399 Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7400 if (D) {
7401 // Track that we have merged the declaration with ID \p ID into the
7402 // pre-existing predefined declaration \p D.
7403 auto &Merged = KeyDecls[D->getCanonicalDecl()];
7404 if (Merged.empty())
7405 Merged.push_back(ID);
7406 }
7407 return D;
7408 }
7409
7410 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7411
7412 if (Index >= DeclsLoaded.size()) {
7413 assert(0 && "declaration ID out-of-range for AST file");
7414 Error("declaration ID out-of-range for AST file");
7415 return nullptr;
7416 }
7417
7418 return DeclsLoaded[Index];
7419 }
7420
GetDecl(DeclID ID)7421 Decl *ASTReader::GetDecl(DeclID ID) {
7422 if (ID < NUM_PREDEF_DECL_IDS)
7423 return GetExistingDecl(ID);
7424
7425 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7426
7427 if (Index >= DeclsLoaded.size()) {
7428 assert(0 && "declaration ID out-of-range for AST file");
7429 Error("declaration ID out-of-range for AST file");
7430 return nullptr;
7431 }
7432
7433 if (!DeclsLoaded[Index]) {
7434 ReadDeclRecord(ID);
7435 if (DeserializationListener)
7436 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7437 }
7438
7439 return DeclsLoaded[Index];
7440 }
7441
mapGlobalIDToModuleFileGlobalID(ModuleFile & M,DeclID GlobalID)7442 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7443 DeclID GlobalID) {
7444 if (GlobalID < NUM_PREDEF_DECL_IDS)
7445 return GlobalID;
7446
7447 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7448 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
7449 ModuleFile *Owner = I->second;
7450
7451 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7452 = M.GlobalToLocalDeclIDs.find(Owner);
7453 if (Pos == M.GlobalToLocalDeclIDs.end())
7454 return 0;
7455
7456 return GlobalID - Owner->BaseDeclID + Pos->second;
7457 }
7458
ReadDeclID(ModuleFile & F,const RecordData & Record,unsigned & Idx)7459 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7460 const RecordData &Record,
7461 unsigned &Idx) {
7462 if (Idx >= Record.size()) {
7463 Error("Corrupted AST file");
7464 return 0;
7465 }
7466
7467 return getGlobalDeclID(F, Record[Idx++]);
7468 }
7469
7470 /// Resolve the offset of a statement into a statement.
7471 ///
7472 /// This operation will read a new statement from the external
7473 /// source each time it is called, and is meant to be used via a
7474 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
GetExternalDeclStmt(uint64_t Offset)7475 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7476 // Switch case IDs are per Decl.
7477 ClearSwitchCaseIDs();
7478
7479 // Offset here is a global offset across the entire chain.
7480 RecordLocation Loc = getLocalBitOffset(Offset);
7481 if (llvm::Error Err = Loc.F->DeclsCursor.JumpToBit(Loc.Offset)) {
7482 Error(std::move(Err));
7483 return nullptr;
7484 }
7485 assert(NumCurrentElementsDeserializing == 0 &&
7486 "should not be called while already deserializing");
7487 Deserializing D(this);
7488 return ReadStmtFromStream(*Loc.F);
7489 }
7490
FindExternalLexicalDecls(const DeclContext * DC,llvm::function_ref<bool (Decl::Kind)> IsKindWeWant,SmallVectorImpl<Decl * > & Decls)7491 void ASTReader::FindExternalLexicalDecls(
7492 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7493 SmallVectorImpl<Decl *> &Decls) {
7494 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7495
7496 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7497 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
7498 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7499 auto K = (Decl::Kind)+LexicalDecls[I];
7500 if (!IsKindWeWant(K))
7501 continue;
7502
7503 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7504
7505 // Don't add predefined declarations to the lexical context more
7506 // than once.
7507 if (ID < NUM_PREDEF_DECL_IDS) {
7508 if (PredefsVisited[ID])
7509 continue;
7510
7511 PredefsVisited[ID] = true;
7512 }
7513
7514 if (Decl *D = GetLocalDecl(*M, ID)) {
7515 assert(D->getKind() == K && "wrong kind for lexical decl");
7516 if (!DC->isDeclInLexicalTraversal(D))
7517 Decls.push_back(D);
7518 }
7519 }
7520 };
7521
7522 if (isa<TranslationUnitDecl>(DC)) {
7523 for (auto Lexical : TULexicalDecls)
7524 Visit(Lexical.first, Lexical.second);
7525 } else {
7526 auto I = LexicalDecls.find(DC);
7527 if (I != LexicalDecls.end())
7528 Visit(I->second.first, I->second.second);
7529 }
7530
7531 ++NumLexicalDeclContextsRead;
7532 }
7533
7534 namespace {
7535
7536 class DeclIDComp {
7537 ASTReader &Reader;
7538 ModuleFile &Mod;
7539
7540 public:
DeclIDComp(ASTReader & Reader,ModuleFile & M)7541 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7542
operator ()(LocalDeclID L,LocalDeclID R) const7543 bool operator()(LocalDeclID L, LocalDeclID R) const {
7544 SourceLocation LHS = getLocation(L);
7545 SourceLocation RHS = getLocation(R);
7546 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7547 }
7548
operator ()(SourceLocation LHS,LocalDeclID R) const7549 bool operator()(SourceLocation LHS, LocalDeclID R) const {
7550 SourceLocation RHS = getLocation(R);
7551 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7552 }
7553
operator ()(LocalDeclID L,SourceLocation RHS) const7554 bool operator()(LocalDeclID L, SourceLocation RHS) const {
7555 SourceLocation LHS = getLocation(L);
7556 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7557 }
7558
getLocation(LocalDeclID ID) const7559 SourceLocation getLocation(LocalDeclID ID) const {
7560 return Reader.getSourceManager().getFileLoc(
7561 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7562 }
7563 };
7564
7565 } // namespace
7566
FindFileRegionDecls(FileID File,unsigned Offset,unsigned Length,SmallVectorImpl<Decl * > & Decls)7567 void ASTReader::FindFileRegionDecls(FileID File,
7568 unsigned Offset, unsigned Length,
7569 SmallVectorImpl<Decl *> &Decls) {
7570 SourceManager &SM = getSourceManager();
7571
7572 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7573 if (I == FileDeclIDs.end())
7574 return;
7575
7576 FileDeclsInfo &DInfo = I->second;
7577 if (DInfo.Decls.empty())
7578 return;
7579
7580 SourceLocation
7581 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7582 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7583
7584 DeclIDComp DIDComp(*this, *DInfo.Mod);
7585 ArrayRef<serialization::LocalDeclID>::iterator BeginIt =
7586 llvm::lower_bound(DInfo.Decls, BeginLoc, DIDComp);
7587 if (BeginIt != DInfo.Decls.begin())
7588 --BeginIt;
7589
7590 // If we are pointing at a top-level decl inside an objc container, we need
7591 // to backtrack until we find it otherwise we will fail to report that the
7592 // region overlaps with an objc container.
7593 while (BeginIt != DInfo.Decls.begin() &&
7594 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7595 ->isTopLevelDeclInObjCContainer())
7596 --BeginIt;
7597
7598 ArrayRef<serialization::LocalDeclID>::iterator EndIt =
7599 llvm::upper_bound(DInfo.Decls, EndLoc, DIDComp);
7600 if (EndIt != DInfo.Decls.end())
7601 ++EndIt;
7602
7603 for (ArrayRef<serialization::LocalDeclID>::iterator
7604 DIt = BeginIt; DIt != EndIt; ++DIt)
7605 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7606 }
7607
7608 bool
FindExternalVisibleDeclsByName(const DeclContext * DC,DeclarationName Name)7609 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7610 DeclarationName Name) {
7611 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
7612 "DeclContext has no visible decls in storage");
7613 if (!Name)
7614 return false;
7615
7616 auto It = Lookups.find(DC);
7617 if (It == Lookups.end())
7618 return false;
7619
7620 Deserializing LookupResults(this);
7621
7622 // Load the list of declarations.
7623 SmallVector<NamedDecl *, 64> Decls;
7624 for (DeclID ID : It->second.Table.find(Name)) {
7625 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7626 if (ND->getDeclName() == Name)
7627 Decls.push_back(ND);
7628 }
7629
7630 ++NumVisibleDeclContextsRead;
7631 SetExternalVisibleDeclsForName(DC, Name, Decls);
7632 return !Decls.empty();
7633 }
7634
completeVisibleDeclsMap(const DeclContext * DC)7635 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7636 if (!DC->hasExternalVisibleStorage())
7637 return;
7638
7639 auto It = Lookups.find(DC);
7640 assert(It != Lookups.end() &&
7641 "have external visible storage but no lookup tables");
7642
7643 DeclsMap Decls;
7644
7645 for (DeclID ID : It->second.Table.findAll()) {
7646 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7647 Decls[ND->getDeclName()].push_back(ND);
7648 }
7649
7650 ++NumVisibleDeclContextsRead;
7651
7652 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7653 SetExternalVisibleDeclsForName(DC, I->first, I->second);
7654 }
7655 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7656 }
7657
7658 const serialization::reader::DeclContextLookupTable *
getLoadedLookupTables(DeclContext * Primary) const7659 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
7660 auto I = Lookups.find(Primary);
7661 return I == Lookups.end() ? nullptr : &I->second;
7662 }
7663
7664 /// Under non-PCH compilation the consumer receives the objc methods
7665 /// before receiving the implementation, and codegen depends on this.
7666 /// We simulate this by deserializing and passing to consumer the methods of the
7667 /// implementation before passing the deserialized implementation decl.
PassObjCImplDeclToConsumer(ObjCImplDecl * ImplD,ASTConsumer * Consumer)7668 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
7669 ASTConsumer *Consumer) {
7670 assert(ImplD && Consumer);
7671
7672 for (auto *I : ImplD->methods())
7673 Consumer->HandleInterestingDecl(DeclGroupRef(I));
7674
7675 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7676 }
7677
PassInterestingDeclToConsumer(Decl * D)7678 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7679 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7680 PassObjCImplDeclToConsumer(ImplD, Consumer);
7681 else
7682 Consumer->HandleInterestingDecl(DeclGroupRef(D));
7683 }
7684
StartTranslationUnit(ASTConsumer * Consumer)7685 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
7686 this->Consumer = Consumer;
7687
7688 if (Consumer)
7689 PassInterestingDeclsToConsumer();
7690
7691 if (DeserializationListener)
7692 DeserializationListener->ReaderInitialized(this);
7693 }
7694
PrintStats()7695 void ASTReader::PrintStats() {
7696 std::fprintf(stderr, "*** AST File Statistics:\n");
7697
7698 unsigned NumTypesLoaded
7699 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7700 QualType());
7701 unsigned NumDeclsLoaded
7702 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7703 (Decl *)nullptr);
7704 unsigned NumIdentifiersLoaded
7705 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7706 IdentifiersLoaded.end(),
7707 (IdentifierInfo *)nullptr);
7708 unsigned NumMacrosLoaded
7709 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7710 MacrosLoaded.end(),
7711 (MacroInfo *)nullptr);
7712 unsigned NumSelectorsLoaded
7713 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7714 SelectorsLoaded.end(),
7715 Selector());
7716
7717 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7718 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
7719 NumSLocEntriesRead, TotalNumSLocEntries,
7720 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7721 if (!TypesLoaded.empty())
7722 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
7723 NumTypesLoaded, (unsigned)TypesLoaded.size(),
7724 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7725 if (!DeclsLoaded.empty())
7726 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
7727 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7728 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7729 if (!IdentifiersLoaded.empty())
7730 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
7731 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7732 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7733 if (!MacrosLoaded.empty())
7734 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7735 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7736 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7737 if (!SelectorsLoaded.empty())
7738 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
7739 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7740 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7741 if (TotalNumStatements)
7742 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
7743 NumStatementsRead, TotalNumStatements,
7744 ((float)NumStatementsRead/TotalNumStatements * 100));
7745 if (TotalNumMacros)
7746 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
7747 NumMacrosRead, TotalNumMacros,
7748 ((float)NumMacrosRead/TotalNumMacros * 100));
7749 if (TotalLexicalDeclContexts)
7750 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
7751 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7752 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7753 * 100));
7754 if (TotalVisibleDeclContexts)
7755 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
7756 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7757 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7758 * 100));
7759 if (TotalNumMethodPoolEntries)
7760 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
7761 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7762 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7763 * 100));
7764 if (NumMethodPoolLookups)
7765 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7766 NumMethodPoolHits, NumMethodPoolLookups,
7767 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7768 if (NumMethodPoolTableLookups)
7769 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7770 NumMethodPoolTableHits, NumMethodPoolTableLookups,
7771 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7772 * 100.0));
7773 if (NumIdentifierLookupHits)
7774 std::fprintf(stderr,
7775 " %u / %u identifier table lookups succeeded (%f%%)\n",
7776 NumIdentifierLookupHits, NumIdentifierLookups,
7777 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7778
7779 if (GlobalIndex) {
7780 std::fprintf(stderr, "\n");
7781 GlobalIndex->printStats();
7782 }
7783
7784 std::fprintf(stderr, "\n");
7785 dump();
7786 std::fprintf(stderr, "\n");
7787 }
7788
7789 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7790 LLVM_DUMP_METHOD static void
dumpModuleIDMap(StringRef Name,const ContinuousRangeMap<Key,ModuleFile *,InitialCapacity> & Map)7791 dumpModuleIDMap(StringRef Name,
7792 const ContinuousRangeMap<Key, ModuleFile *,
7793 InitialCapacity> &Map) {
7794 if (Map.begin() == Map.end())
7795 return;
7796
7797 using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
7798
7799 llvm::errs() << Name << ":\n";
7800 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7801 I != IEnd; ++I) {
7802 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7803 << "\n";
7804 }
7805 }
7806
dump()7807 LLVM_DUMP_METHOD void ASTReader::dump() {
7808 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7809 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7810 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7811 dumpModuleIDMap("Global type map", GlobalTypeMap);
7812 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7813 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7814 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7815 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7816 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7817 dumpModuleIDMap("Global preprocessed entity map",
7818 GlobalPreprocessedEntityMap);
7819
7820 llvm::errs() << "\n*** PCH/Modules Loaded:";
7821 for (ModuleFile &M : ModuleMgr)
7822 M.dump();
7823 }
7824
7825 /// Return the amount of memory used by memory buffers, breaking down
7826 /// by heap-backed versus mmap'ed memory.
getMemoryBufferSizes(MemoryBufferSizes & sizes) const7827 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7828 for (ModuleFile &I : ModuleMgr) {
7829 if (llvm::MemoryBuffer *buf = I.Buffer) {
7830 size_t bytes = buf->getBufferSize();
7831 switch (buf->getBufferKind()) {
7832 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7833 sizes.malloc_bytes += bytes;
7834 break;
7835 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7836 sizes.mmap_bytes += bytes;
7837 break;
7838 }
7839 }
7840 }
7841 }
7842
InitializeSema(Sema & S)7843 void ASTReader::InitializeSema(Sema &S) {
7844 SemaObj = &S;
7845 S.addExternalSource(this);
7846
7847 // Makes sure any declarations that were deserialized "too early"
7848 // still get added to the identifier's declaration chains.
7849 for (uint64_t ID : PreloadedDeclIDs) {
7850 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7851 pushExternalDeclIntoScope(D, D->getDeclName());
7852 }
7853 PreloadedDeclIDs.clear();
7854
7855 // FIXME: What happens if these are changed by a module import?
7856 if (!FPPragmaOptions.empty()) {
7857 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
7858 FPOptionsOverride NewOverrides(FPPragmaOptions[0]);
7859 SemaObj->CurFPFeatures =
7860 NewOverrides.applyOverrides(SemaObj->getLangOpts());
7861 }
7862
7863 SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7864 SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7865 SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7866
7867 UpdateSema();
7868 }
7869
UpdateSema()7870 void ASTReader::UpdateSema() {
7871 assert(SemaObj && "no Sema to update");
7872
7873 // Load the offsets of the declarations that Sema references.
7874 // They will be lazily deserialized when needed.
7875 if (!SemaDeclRefs.empty()) {
7876 assert(SemaDeclRefs.size() % 3 == 0);
7877 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7878 if (!SemaObj->StdNamespace)
7879 SemaObj->StdNamespace = SemaDeclRefs[I];
7880 if (!SemaObj->StdBadAlloc)
7881 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7882 if (!SemaObj->StdAlignValT)
7883 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7884 }
7885 SemaDeclRefs.clear();
7886 }
7887
7888 // Update the state of pragmas. Use the same API as if we had encountered the
7889 // pragma in the source.
7890 if(OptimizeOffPragmaLocation.isValid())
7891 SemaObj->ActOnPragmaOptimize(/* On = */ false, OptimizeOffPragmaLocation);
7892 if (PragmaMSStructState != -1)
7893 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7894 if (PointersToMembersPragmaLocation.isValid()) {
7895 SemaObj->ActOnPragmaMSPointersToMembers(
7896 (LangOptions::PragmaMSPointersToMembersKind)
7897 PragmaMSPointersToMembersState,
7898 PointersToMembersPragmaLocation);
7899 }
7900 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7901
7902 if (PragmaPackCurrentValue) {
7903 // The bottom of the stack might have a default value. It must be adjusted
7904 // to the current value to ensure that the packing state is preserved after
7905 // popping entries that were included/imported from a PCH/module.
7906 bool DropFirst = false;
7907 if (!PragmaPackStack.empty() &&
7908 PragmaPackStack.front().Location.isInvalid()) {
7909 assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&
7910 "Expected a default alignment value");
7911 SemaObj->PackStack.Stack.emplace_back(
7912 PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7913 SemaObj->PackStack.CurrentPragmaLocation,
7914 PragmaPackStack.front().PushLocation);
7915 DropFirst = true;
7916 }
7917 for (const auto &Entry :
7918 llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7919 SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7920 Entry.Location, Entry.PushLocation);
7921 if (PragmaPackCurrentLocation.isInvalid()) {
7922 assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&
7923 "Expected a default alignment value");
7924 // Keep the current values.
7925 } else {
7926 SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7927 SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7928 }
7929 }
7930 if (FpPragmaCurrentValue) {
7931 // The bottom of the stack might have a default value. It must be adjusted
7932 // to the current value to ensure that fp-pragma state is preserved after
7933 // popping entries that were included/imported from a PCH/module.
7934 bool DropFirst = false;
7935 if (!FpPragmaStack.empty() && FpPragmaStack.front().Location.isInvalid()) {
7936 assert(FpPragmaStack.front().Value ==
7937 SemaObj->FpPragmaStack.DefaultValue &&
7938 "Expected a default pragma float_control value");
7939 SemaObj->FpPragmaStack.Stack.emplace_back(
7940 FpPragmaStack.front().SlotLabel, SemaObj->FpPragmaStack.CurrentValue,
7941 SemaObj->FpPragmaStack.CurrentPragmaLocation,
7942 FpPragmaStack.front().PushLocation);
7943 DropFirst = true;
7944 }
7945 for (const auto &Entry :
7946 llvm::makeArrayRef(FpPragmaStack).drop_front(DropFirst ? 1 : 0))
7947 SemaObj->FpPragmaStack.Stack.emplace_back(
7948 Entry.SlotLabel, Entry.Value, Entry.Location, Entry.PushLocation);
7949 if (FpPragmaCurrentLocation.isInvalid()) {
7950 assert(*FpPragmaCurrentValue == SemaObj->FpPragmaStack.DefaultValue &&
7951 "Expected a default pragma float_control value");
7952 // Keep the current values.
7953 } else {
7954 SemaObj->FpPragmaStack.CurrentValue = *FpPragmaCurrentValue;
7955 SemaObj->FpPragmaStack.CurrentPragmaLocation = FpPragmaCurrentLocation;
7956 }
7957 }
7958 }
7959
get(StringRef Name)7960 IdentifierInfo *ASTReader::get(StringRef Name) {
7961 // Note that we are loading an identifier.
7962 Deserializing AnIdentifier(this);
7963
7964 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7965 NumIdentifierLookups,
7966 NumIdentifierLookupHits);
7967
7968 // We don't need to do identifier table lookups in C++ modules (we preload
7969 // all interesting declarations, and don't need to use the scope for name
7970 // lookups). Perform the lookup in PCH files, though, since we don't build
7971 // a complete initial identifier table if we're carrying on from a PCH.
7972 if (PP.getLangOpts().CPlusPlus) {
7973 for (auto F : ModuleMgr.pch_modules())
7974 if (Visitor(*F))
7975 break;
7976 } else {
7977 // If there is a global index, look there first to determine which modules
7978 // provably do not have any results for this identifier.
7979 GlobalModuleIndex::HitSet Hits;
7980 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7981 if (!loadGlobalIndex()) {
7982 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7983 HitsPtr = &Hits;
7984 }
7985 }
7986
7987 ModuleMgr.visit(Visitor, HitsPtr);
7988 }
7989
7990 IdentifierInfo *II = Visitor.getIdentifierInfo();
7991 markIdentifierUpToDate(II);
7992 return II;
7993 }
7994
7995 namespace clang {
7996
7997 /// An identifier-lookup iterator that enumerates all of the
7998 /// identifiers stored within a set of AST files.
7999 class ASTIdentifierIterator : public IdentifierIterator {
8000 /// The AST reader whose identifiers are being enumerated.
8001 const ASTReader &Reader;
8002
8003 /// The current index into the chain of AST files stored in
8004 /// the AST reader.
8005 unsigned Index;
8006
8007 /// The current position within the identifier lookup table
8008 /// of the current AST file.
8009 ASTIdentifierLookupTable::key_iterator Current;
8010
8011 /// The end position within the identifier lookup table of
8012 /// the current AST file.
8013 ASTIdentifierLookupTable::key_iterator End;
8014
8015 /// Whether to skip any modules in the ASTReader.
8016 bool SkipModules;
8017
8018 public:
8019 explicit ASTIdentifierIterator(const ASTReader &Reader,
8020 bool SkipModules = false);
8021
8022 StringRef Next() override;
8023 };
8024
8025 } // namespace clang
8026
ASTIdentifierIterator(const ASTReader & Reader,bool SkipModules)8027 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
8028 bool SkipModules)
8029 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
8030 }
8031
Next()8032 StringRef ASTIdentifierIterator::Next() {
8033 while (Current == End) {
8034 // If we have exhausted all of our AST files, we're done.
8035 if (Index == 0)
8036 return StringRef();
8037
8038 --Index;
8039 ModuleFile &F = Reader.ModuleMgr[Index];
8040 if (SkipModules && F.isModule())
8041 continue;
8042
8043 ASTIdentifierLookupTable *IdTable =
8044 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
8045 Current = IdTable->key_begin();
8046 End = IdTable->key_end();
8047 }
8048
8049 // We have any identifiers remaining in the current AST file; return
8050 // the next one.
8051 StringRef Result = *Current;
8052 ++Current;
8053 return Result;
8054 }
8055
8056 namespace {
8057
8058 /// A utility for appending two IdentifierIterators.
8059 class ChainedIdentifierIterator : public IdentifierIterator {
8060 std::unique_ptr<IdentifierIterator> Current;
8061 std::unique_ptr<IdentifierIterator> Queued;
8062
8063 public:
ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,std::unique_ptr<IdentifierIterator> Second)8064 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
8065 std::unique_ptr<IdentifierIterator> Second)
8066 : Current(std::move(First)), Queued(std::move(Second)) {}
8067
Next()8068 StringRef Next() override {
8069 if (!Current)
8070 return StringRef();
8071
8072 StringRef result = Current->Next();
8073 if (!result.empty())
8074 return result;
8075
8076 // Try the queued iterator, which may itself be empty.
8077 Current.reset();
8078 std::swap(Current, Queued);
8079 return Next();
8080 }
8081 };
8082
8083 } // namespace
8084
getIdentifiers()8085 IdentifierIterator *ASTReader::getIdentifiers() {
8086 if (!loadGlobalIndex()) {
8087 std::unique_ptr<IdentifierIterator> ReaderIter(
8088 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
8089 std::unique_ptr<IdentifierIterator> ModulesIter(
8090 GlobalIndex->createIdentifierIterator());
8091 return new ChainedIdentifierIterator(std::move(ReaderIter),
8092 std::move(ModulesIter));
8093 }
8094
8095 return new ASTIdentifierIterator(*this);
8096 }
8097
8098 namespace clang {
8099 namespace serialization {
8100
8101 class ReadMethodPoolVisitor {
8102 ASTReader &Reader;
8103 Selector Sel;
8104 unsigned PriorGeneration;
8105 unsigned InstanceBits = 0;
8106 unsigned FactoryBits = 0;
8107 bool InstanceHasMoreThanOneDecl = false;
8108 bool FactoryHasMoreThanOneDecl = false;
8109 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8110 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8111
8112 public:
ReadMethodPoolVisitor(ASTReader & Reader,Selector Sel,unsigned PriorGeneration)8113 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8114 unsigned PriorGeneration)
8115 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8116
operator ()(ModuleFile & M)8117 bool operator()(ModuleFile &M) {
8118 if (!M.SelectorLookupTable)
8119 return false;
8120
8121 // If we've already searched this module file, skip it now.
8122 if (M.Generation <= PriorGeneration)
8123 return true;
8124
8125 ++Reader.NumMethodPoolTableLookups;
8126 ASTSelectorLookupTable *PoolTable
8127 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8128 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8129 if (Pos == PoolTable->end())
8130 return false;
8131
8132 ++Reader.NumMethodPoolTableHits;
8133 ++Reader.NumSelectorsRead;
8134 // FIXME: Not quite happy with the statistics here. We probably should
8135 // disable this tracking when called via LoadSelector.
8136 // Also, should entries without methods count as misses?
8137 ++Reader.NumMethodPoolEntriesRead;
8138 ASTSelectorLookupTrait::data_type Data = *Pos;
8139 if (Reader.DeserializationListener)
8140 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8141
8142 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8143 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8144 InstanceBits = Data.InstanceBits;
8145 FactoryBits = Data.FactoryBits;
8146 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8147 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8148 return true;
8149 }
8150
8151 /// Retrieve the instance methods found by this visitor.
getInstanceMethods() const8152 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8153 return InstanceMethods;
8154 }
8155
8156 /// Retrieve the instance methods found by this visitor.
getFactoryMethods() const8157 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8158 return FactoryMethods;
8159 }
8160
getInstanceBits() const8161 unsigned getInstanceBits() const { return InstanceBits; }
getFactoryBits() const8162 unsigned getFactoryBits() const { return FactoryBits; }
8163
instanceHasMoreThanOneDecl() const8164 bool instanceHasMoreThanOneDecl() const {
8165 return InstanceHasMoreThanOneDecl;
8166 }
8167
factoryHasMoreThanOneDecl() const8168 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8169 };
8170
8171 } // namespace serialization
8172 } // namespace clang
8173
8174 /// Add the given set of methods to the method list.
addMethodsToPool(Sema & S,ArrayRef<ObjCMethodDecl * > Methods,ObjCMethodList & List)8175 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8176 ObjCMethodList &List) {
8177 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8178 S.addMethodToGlobalList(&List, Methods[I]);
8179 }
8180 }
8181
ReadMethodPool(Selector Sel)8182 void ASTReader::ReadMethodPool(Selector Sel) {
8183 // Get the selector generation and update it to the current generation.
8184 unsigned &Generation = SelectorGeneration[Sel];
8185 unsigned PriorGeneration = Generation;
8186 Generation = getGeneration();
8187 SelectorOutOfDate[Sel] = false;
8188
8189 // Search for methods defined with this selector.
8190 ++NumMethodPoolLookups;
8191 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8192 ModuleMgr.visit(Visitor);
8193
8194 if (Visitor.getInstanceMethods().empty() &&
8195 Visitor.getFactoryMethods().empty())
8196 return;
8197
8198 ++NumMethodPoolHits;
8199
8200 if (!getSema())
8201 return;
8202
8203 Sema &S = *getSema();
8204 Sema::GlobalMethodPool::iterator Pos
8205 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8206
8207 Pos->second.first.setBits(Visitor.getInstanceBits());
8208 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8209 Pos->second.second.setBits(Visitor.getFactoryBits());
8210 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8211
8212 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8213 // when building a module we keep every method individually and may need to
8214 // update hasMoreThanOneDecl as we add the methods.
8215 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8216 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8217 }
8218
updateOutOfDateSelector(Selector Sel)8219 void ASTReader::updateOutOfDateSelector(Selector Sel) {
8220 if (SelectorOutOfDate[Sel])
8221 ReadMethodPool(Sel);
8222 }
8223
ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl * > & Namespaces)8224 void ASTReader::ReadKnownNamespaces(
8225 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8226 Namespaces.clear();
8227
8228 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8229 if (NamespaceDecl *Namespace
8230 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8231 Namespaces.push_back(Namespace);
8232 }
8233 }
8234
ReadUndefinedButUsed(llvm::MapVector<NamedDecl *,SourceLocation> & Undefined)8235 void ASTReader::ReadUndefinedButUsed(
8236 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8237 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8238 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8239 SourceLocation Loc =
8240 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8241 Undefined.insert(std::make_pair(D, Loc));
8242 }
8243 }
8244
ReadMismatchingDeleteExpressions(llvm::MapVector<FieldDecl *,llvm::SmallVector<std::pair<SourceLocation,bool>,4>> & Exprs)8245 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8246 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8247 Exprs) {
8248 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8249 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8250 uint64_t Count = DelayedDeleteExprs[Idx++];
8251 for (uint64_t C = 0; C < Count; ++C) {
8252 SourceLocation DeleteLoc =
8253 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8254 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8255 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8256 }
8257 }
8258 }
8259
ReadTentativeDefinitions(SmallVectorImpl<VarDecl * > & TentativeDefs)8260 void ASTReader::ReadTentativeDefinitions(
8261 SmallVectorImpl<VarDecl *> &TentativeDefs) {
8262 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8263 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8264 if (Var)
8265 TentativeDefs.push_back(Var);
8266 }
8267 TentativeDefinitions.clear();
8268 }
8269
ReadUnusedFileScopedDecls(SmallVectorImpl<const DeclaratorDecl * > & Decls)8270 void ASTReader::ReadUnusedFileScopedDecls(
8271 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8272 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8273 DeclaratorDecl *D
8274 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8275 if (D)
8276 Decls.push_back(D);
8277 }
8278 UnusedFileScopedDecls.clear();
8279 }
8280
ReadDelegatingConstructors(SmallVectorImpl<CXXConstructorDecl * > & Decls)8281 void ASTReader::ReadDelegatingConstructors(
8282 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8283 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8284 CXXConstructorDecl *D
8285 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8286 if (D)
8287 Decls.push_back(D);
8288 }
8289 DelegatingCtorDecls.clear();
8290 }
8291
ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl * > & Decls)8292 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8293 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8294 TypedefNameDecl *D
8295 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8296 if (D)
8297 Decls.push_back(D);
8298 }
8299 ExtVectorDecls.clear();
8300 }
8301
ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector<const TypedefNameDecl *,4> & Decls)8302 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8303 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8304 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8305 ++I) {
8306 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8307 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8308 if (D)
8309 Decls.insert(D);
8310 }
8311 UnusedLocalTypedefNameCandidates.clear();
8312 }
8313
ReadDeclsToCheckForDeferredDiags(llvm::SmallVector<Decl *,4> & Decls)8314 void ASTReader::ReadDeclsToCheckForDeferredDiags(
8315 llvm::SmallVector<Decl *, 4> &Decls) {
8316 for (unsigned I = 0, N = DeclsToCheckForDeferredDiags.size(); I != N;
8317 ++I) {
8318 auto *D = dyn_cast_or_null<Decl>(
8319 GetDecl(DeclsToCheckForDeferredDiags[I]));
8320 if (D)
8321 Decls.push_back(D);
8322 }
8323 DeclsToCheckForDeferredDiags.clear();
8324 }
8325
8326
ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector,SourceLocation>> & Sels)8327 void ASTReader::ReadReferencedSelectors(
8328 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8329 if (ReferencedSelectorsData.empty())
8330 return;
8331
8332 // If there are @selector references added them to its pool. This is for
8333 // implementation of -Wselector.
8334 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8335 unsigned I = 0;
8336 while (I < DataSize) {
8337 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8338 SourceLocation SelLoc
8339 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8340 Sels.push_back(std::make_pair(Sel, SelLoc));
8341 }
8342 ReferencedSelectorsData.clear();
8343 }
8344
ReadWeakUndeclaredIdentifiers(SmallVectorImpl<std::pair<IdentifierInfo *,WeakInfo>> & WeakIDs)8345 void ASTReader::ReadWeakUndeclaredIdentifiers(
8346 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8347 if (WeakUndeclaredIdentifiers.empty())
8348 return;
8349
8350 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8351 IdentifierInfo *WeakId
8352 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8353 IdentifierInfo *AliasId
8354 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8355 SourceLocation Loc
8356 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8357 bool Used = WeakUndeclaredIdentifiers[I++];
8358 WeakInfo WI(AliasId, Loc);
8359 WI.setUsed(Used);
8360 WeakIDs.push_back(std::make_pair(WeakId, WI));
8361 }
8362 WeakUndeclaredIdentifiers.clear();
8363 }
8364
ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> & VTables)8365 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8366 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8367 ExternalVTableUse VT;
8368 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8369 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8370 VT.DefinitionRequired = VTableUses[Idx++];
8371 VTables.push_back(VT);
8372 }
8373
8374 VTableUses.clear();
8375 }
8376
ReadPendingInstantiations(SmallVectorImpl<std::pair<ValueDecl *,SourceLocation>> & Pending)8377 void ASTReader::ReadPendingInstantiations(
8378 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8379 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8380 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8381 SourceLocation Loc
8382 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8383
8384 Pending.push_back(std::make_pair(D, Loc));
8385 }
8386 PendingInstantiations.clear();
8387 }
8388
ReadLateParsedTemplates(llvm::MapVector<const FunctionDecl *,std::unique_ptr<LateParsedTemplate>> & LPTMap)8389 void ASTReader::ReadLateParsedTemplates(
8390 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8391 &LPTMap) {
8392 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8393 /* In loop */) {
8394 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8395
8396 auto LT = std::make_unique<LateParsedTemplate>();
8397 LT->D = GetDecl(LateParsedTemplates[Idx++]);
8398
8399 ModuleFile *F = getOwningModuleFile(LT->D);
8400 assert(F && "No module");
8401
8402 unsigned TokN = LateParsedTemplates[Idx++];
8403 LT->Toks.reserve(TokN);
8404 for (unsigned T = 0; T < TokN; ++T)
8405 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8406
8407 LPTMap.insert(std::make_pair(FD, std::move(LT)));
8408 }
8409
8410 LateParsedTemplates.clear();
8411 }
8412
LoadSelector(Selector Sel)8413 void ASTReader::LoadSelector(Selector Sel) {
8414 // It would be complicated to avoid reading the methods anyway. So don't.
8415 ReadMethodPool(Sel);
8416 }
8417
SetIdentifierInfo(IdentifierID ID,IdentifierInfo * II)8418 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8419 assert(ID && "Non-zero identifier ID required");
8420 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
8421 IdentifiersLoaded[ID - 1] = II;
8422 if (DeserializationListener)
8423 DeserializationListener->IdentifierRead(ID, II);
8424 }
8425
8426 /// Set the globally-visible declarations associated with the given
8427 /// identifier.
8428 ///
8429 /// If the AST reader is currently in a state where the given declaration IDs
8430 /// cannot safely be resolved, they are queued until it is safe to resolve
8431 /// them.
8432 ///
8433 /// \param II an IdentifierInfo that refers to one or more globally-visible
8434 /// declarations.
8435 ///
8436 /// \param DeclIDs the set of declaration IDs with the name @p II that are
8437 /// visible at global scope.
8438 ///
8439 /// \param Decls if non-null, this vector will be populated with the set of
8440 /// deserialized declarations. These declarations will not be pushed into
8441 /// scope.
8442 void
SetGloballyVisibleDecls(IdentifierInfo * II,const SmallVectorImpl<uint32_t> & DeclIDs,SmallVectorImpl<Decl * > * Decls)8443 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8444 const SmallVectorImpl<uint32_t> &DeclIDs,
8445 SmallVectorImpl<Decl *> *Decls) {
8446 if (NumCurrentElementsDeserializing && !Decls) {
8447 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8448 return;
8449 }
8450
8451 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8452 if (!SemaObj) {
8453 // Queue this declaration so that it will be added to the
8454 // translation unit scope and identifier's declaration chain
8455 // once a Sema object is known.
8456 PreloadedDeclIDs.push_back(DeclIDs[I]);
8457 continue;
8458 }
8459
8460 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8461
8462 // If we're simply supposed to record the declarations, do so now.
8463 if (Decls) {
8464 Decls->push_back(D);
8465 continue;
8466 }
8467
8468 // Introduce this declaration into the translation-unit scope
8469 // and add it to the declaration chain for this identifier, so
8470 // that (unqualified) name lookup will find it.
8471 pushExternalDeclIntoScope(D, II);
8472 }
8473 }
8474
DecodeIdentifierInfo(IdentifierID ID)8475 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8476 if (ID == 0)
8477 return nullptr;
8478
8479 if (IdentifiersLoaded.empty()) {
8480 Error("no identifier table in AST file");
8481 return nullptr;
8482 }
8483
8484 ID -= 1;
8485 if (!IdentifiersLoaded[ID]) {
8486 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8487 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
8488 ModuleFile *M = I->second;
8489 unsigned Index = ID - M->BaseIdentifierID;
8490 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8491
8492 // All of the strings in the AST file are preceded by a 16-bit length.
8493 // Extract that 16-bit length to avoid having to execute strlen().
8494 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8495 // unsigned integers. This is important to avoid integer overflow when
8496 // we cast them to 'unsigned'.
8497 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8498 unsigned StrLen = (((unsigned) StrLenPtr[0])
8499 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8500 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8501 IdentifiersLoaded[ID] = &II;
8502 markIdentifierFromAST(*this, II);
8503 if (DeserializationListener)
8504 DeserializationListener->IdentifierRead(ID + 1, &II);
8505 }
8506
8507 return IdentifiersLoaded[ID];
8508 }
8509
getLocalIdentifier(ModuleFile & M,unsigned LocalID)8510 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8511 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8512 }
8513
getGlobalIdentifierID(ModuleFile & M,unsigned LocalID)8514 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8515 if (LocalID < NUM_PREDEF_IDENT_IDS)
8516 return LocalID;
8517
8518 if (!M.ModuleOffsetMap.empty())
8519 ReadModuleOffsetMap(M);
8520
8521 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8522 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8523 assert(I != M.IdentifierRemap.end()
8524 && "Invalid index into identifier index remap");
8525
8526 return LocalID + I->second;
8527 }
8528
getMacro(MacroID ID)8529 MacroInfo *ASTReader::getMacro(MacroID ID) {
8530 if (ID == 0)
8531 return nullptr;
8532
8533 if (MacrosLoaded.empty()) {
8534 Error("no macro table in AST file");
8535 return nullptr;
8536 }
8537
8538 ID -= NUM_PREDEF_MACRO_IDS;
8539 if (!MacrosLoaded[ID]) {
8540 GlobalMacroMapType::iterator I
8541 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8542 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
8543 ModuleFile *M = I->second;
8544 unsigned Index = ID - M->BaseMacroID;
8545 MacrosLoaded[ID] =
8546 ReadMacroRecord(*M, M->MacroOffsetsBase + M->MacroOffsets[Index]);
8547
8548 if (DeserializationListener)
8549 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8550 MacrosLoaded[ID]);
8551 }
8552
8553 return MacrosLoaded[ID];
8554 }
8555
getGlobalMacroID(ModuleFile & M,unsigned LocalID)8556 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8557 if (LocalID < NUM_PREDEF_MACRO_IDS)
8558 return LocalID;
8559
8560 if (!M.ModuleOffsetMap.empty())
8561 ReadModuleOffsetMap(M);
8562
8563 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8564 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8565 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
8566
8567 return LocalID + I->second;
8568 }
8569
8570 serialization::SubmoduleID
getGlobalSubmoduleID(ModuleFile & M,unsigned LocalID)8571 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8572 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8573 return LocalID;
8574
8575 if (!M.ModuleOffsetMap.empty())
8576 ReadModuleOffsetMap(M);
8577
8578 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8579 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8580 assert(I != M.SubmoduleRemap.end()
8581 && "Invalid index into submodule index remap");
8582
8583 return LocalID + I->second;
8584 }
8585
getSubmodule(SubmoduleID GlobalID)8586 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8587 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8588 assert(GlobalID == 0 && "Unhandled global submodule ID");
8589 return nullptr;
8590 }
8591
8592 if (GlobalID > SubmodulesLoaded.size()) {
8593 Error("submodule ID out of range in AST file");
8594 return nullptr;
8595 }
8596
8597 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8598 }
8599
getModule(unsigned ID)8600 Module *ASTReader::getModule(unsigned ID) {
8601 return getSubmodule(ID);
8602 }
8603
DeclIsFromPCHWithObjectFile(const Decl * D)8604 bool ASTReader::DeclIsFromPCHWithObjectFile(const Decl *D) {
8605 ModuleFile *MF = getOwningModuleFile(D);
8606 return MF && MF->PCHHasObjectFile;
8607 }
8608
getLocalModuleFile(ModuleFile & F,unsigned ID)8609 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8610 if (ID & 1) {
8611 // It's a module, look it up by submodule ID.
8612 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8613 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8614 } else {
8615 // It's a prefix (preamble, PCH, ...). Look it up by index.
8616 unsigned IndexFromEnd = ID >> 1;
8617 assert(IndexFromEnd && "got reference to unknown module file");
8618 return getModuleManager().pch_modules().end()[-IndexFromEnd];
8619 }
8620 }
8621
getModuleFileID(ModuleFile * F)8622 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8623 if (!F)
8624 return 1;
8625
8626 // For a file representing a module, use the submodule ID of the top-level
8627 // module as the file ID. For any other kind of file, the number of such
8628 // files loaded beforehand will be the same on reload.
8629 // FIXME: Is this true even if we have an explicit module file and a PCH?
8630 if (F->isModule())
8631 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8632
8633 auto PCHModules = getModuleManager().pch_modules();
8634 auto I = llvm::find(PCHModules, F);
8635 assert(I != PCHModules.end() && "emitting reference to unknown file");
8636 return (I - PCHModules.end()) << 1;
8637 }
8638
8639 llvm::Optional<ASTSourceDescriptor>
getSourceDescriptor(unsigned ID)8640 ASTReader::getSourceDescriptor(unsigned ID) {
8641 if (Module *M = getSubmodule(ID))
8642 return ASTSourceDescriptor(*M);
8643
8644 // If there is only a single PCH, return it instead.
8645 // Chained PCH are not supported.
8646 const auto &PCHChain = ModuleMgr.pch_modules();
8647 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8648 ModuleFile &MF = ModuleMgr.getPrimaryModule();
8649 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8650 StringRef FileName = llvm::sys::path::filename(MF.FileName);
8651 return ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8652 MF.Signature);
8653 }
8654 return None;
8655 }
8656
hasExternalDefinitions(const Decl * FD)8657 ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
8658 auto I = DefinitionSource.find(FD);
8659 if (I == DefinitionSource.end())
8660 return EK_ReplyHazy;
8661 return I->second ? EK_Never : EK_Always;
8662 }
8663
getLocalSelector(ModuleFile & M,unsigned LocalID)8664 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8665 return DecodeSelector(getGlobalSelectorID(M, LocalID));
8666 }
8667
DecodeSelector(serialization::SelectorID ID)8668 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
8669 if (ID == 0)
8670 return Selector();
8671
8672 if (ID > SelectorsLoaded.size()) {
8673 Error("selector ID out of range in AST file");
8674 return Selector();
8675 }
8676
8677 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8678 // Load this selector from the selector table.
8679 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8680 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
8681 ModuleFile &M = *I->second;
8682 ASTSelectorLookupTrait Trait(*this, M);
8683 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8684 SelectorsLoaded[ID - 1] =
8685 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8686 if (DeserializationListener)
8687 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8688 }
8689
8690 return SelectorsLoaded[ID - 1];
8691 }
8692
GetExternalSelector(serialization::SelectorID ID)8693 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
8694 return DecodeSelector(ID);
8695 }
8696
GetNumExternalSelectors()8697 uint32_t ASTReader::GetNumExternalSelectors() {
8698 // ID 0 (the null selector) is considered an external selector.
8699 return getTotalNumSelectors() + 1;
8700 }
8701
8702 serialization::SelectorID
getGlobalSelectorID(ModuleFile & M,unsigned LocalID) const8703 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8704 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8705 return LocalID;
8706
8707 if (!M.ModuleOffsetMap.empty())
8708 ReadModuleOffsetMap(M);
8709
8710 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8711 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
8712 assert(I != M.SelectorRemap.end()
8713 && "Invalid index into selector index remap");
8714
8715 return LocalID + I->second;
8716 }
8717
8718 DeclarationNameLoc
readDeclarationNameLoc(DeclarationName Name)8719 ASTRecordReader::readDeclarationNameLoc(DeclarationName Name) {
8720 DeclarationNameLoc DNLoc;
8721 switch (Name.getNameKind()) {
8722 case DeclarationName::CXXConstructorName:
8723 case DeclarationName::CXXDestructorName:
8724 case DeclarationName::CXXConversionFunctionName:
8725 DNLoc.NamedType.TInfo = readTypeSourceInfo();
8726 break;
8727
8728 case DeclarationName::CXXOperatorName:
8729 DNLoc.CXXOperatorName.BeginOpNameLoc
8730 = readSourceLocation().getRawEncoding();
8731 DNLoc.CXXOperatorName.EndOpNameLoc
8732 = readSourceLocation().getRawEncoding();
8733 break;
8734
8735 case DeclarationName::CXXLiteralOperatorName:
8736 DNLoc.CXXLiteralOperatorName.OpNameLoc
8737 = readSourceLocation().getRawEncoding();
8738 break;
8739
8740 case DeclarationName::Identifier:
8741 case DeclarationName::ObjCZeroArgSelector:
8742 case DeclarationName::ObjCOneArgSelector:
8743 case DeclarationName::ObjCMultiArgSelector:
8744 case DeclarationName::CXXUsingDirective:
8745 case DeclarationName::CXXDeductionGuideName:
8746 break;
8747 }
8748 return DNLoc;
8749 }
8750
readDeclarationNameInfo()8751 DeclarationNameInfo ASTRecordReader::readDeclarationNameInfo() {
8752 DeclarationNameInfo NameInfo;
8753 NameInfo.setName(readDeclarationName());
8754 NameInfo.setLoc(readSourceLocation());
8755 NameInfo.setInfo(readDeclarationNameLoc(NameInfo.getName()));
8756 return NameInfo;
8757 }
8758
readQualifierInfo(QualifierInfo & Info)8759 void ASTRecordReader::readQualifierInfo(QualifierInfo &Info) {
8760 Info.QualifierLoc = readNestedNameSpecifierLoc();
8761 unsigned NumTPLists = readInt();
8762 Info.NumTemplParamLists = NumTPLists;
8763 if (NumTPLists) {
8764 Info.TemplParamLists =
8765 new (getContext()) TemplateParameterList *[NumTPLists];
8766 for (unsigned i = 0; i != NumTPLists; ++i)
8767 Info.TemplParamLists[i] = readTemplateParameterList();
8768 }
8769 }
8770
8771 TemplateParameterList *
readTemplateParameterList()8772 ASTRecordReader::readTemplateParameterList() {
8773 SourceLocation TemplateLoc = readSourceLocation();
8774 SourceLocation LAngleLoc = readSourceLocation();
8775 SourceLocation RAngleLoc = readSourceLocation();
8776
8777 unsigned NumParams = readInt();
8778 SmallVector<NamedDecl *, 16> Params;
8779 Params.reserve(NumParams);
8780 while (NumParams--)
8781 Params.push_back(readDeclAs<NamedDecl>());
8782
8783 bool HasRequiresClause = readBool();
8784 Expr *RequiresClause = HasRequiresClause ? readExpr() : nullptr;
8785
8786 TemplateParameterList *TemplateParams = TemplateParameterList::Create(
8787 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, RequiresClause);
8788 return TemplateParams;
8789 }
8790
readTemplateArgumentList(SmallVectorImpl<TemplateArgument> & TemplArgs,bool Canonicalize)8791 void ASTRecordReader::readTemplateArgumentList(
8792 SmallVectorImpl<TemplateArgument> &TemplArgs,
8793 bool Canonicalize) {
8794 unsigned NumTemplateArgs = readInt();
8795 TemplArgs.reserve(NumTemplateArgs);
8796 while (NumTemplateArgs--)
8797 TemplArgs.push_back(readTemplateArgument(Canonicalize));
8798 }
8799
8800 /// Read a UnresolvedSet structure.
readUnresolvedSet(LazyASTUnresolvedSet & Set)8801 void ASTRecordReader::readUnresolvedSet(LazyASTUnresolvedSet &Set) {
8802 unsigned NumDecls = readInt();
8803 Set.reserve(getContext(), NumDecls);
8804 while (NumDecls--) {
8805 DeclID ID = readDeclID();
8806 AccessSpecifier AS = (AccessSpecifier) readInt();
8807 Set.addLazyDecl(getContext(), ID, AS);
8808 }
8809 }
8810
8811 CXXBaseSpecifier
readCXXBaseSpecifier()8812 ASTRecordReader::readCXXBaseSpecifier() {
8813 bool isVirtual = readBool();
8814 bool isBaseOfClass = readBool();
8815 AccessSpecifier AS = static_cast<AccessSpecifier>(readInt());
8816 bool inheritConstructors = readBool();
8817 TypeSourceInfo *TInfo = readTypeSourceInfo();
8818 SourceRange Range = readSourceRange();
8819 SourceLocation EllipsisLoc = readSourceLocation();
8820 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8821 EllipsisLoc);
8822 Result.setInheritConstructors(inheritConstructors);
8823 return Result;
8824 }
8825
8826 CXXCtorInitializer **
readCXXCtorInitializers()8827 ASTRecordReader::readCXXCtorInitializers() {
8828 ASTContext &Context = getContext();
8829 unsigned NumInitializers = readInt();
8830 assert(NumInitializers && "wrote ctor initializers but have no inits");
8831 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8832 for (unsigned i = 0; i != NumInitializers; ++i) {
8833 TypeSourceInfo *TInfo = nullptr;
8834 bool IsBaseVirtual = false;
8835 FieldDecl *Member = nullptr;
8836 IndirectFieldDecl *IndirectMember = nullptr;
8837
8838 CtorInitializerType Type = (CtorInitializerType) readInt();
8839 switch (Type) {
8840 case CTOR_INITIALIZER_BASE:
8841 TInfo = readTypeSourceInfo();
8842 IsBaseVirtual = readBool();
8843 break;
8844
8845 case CTOR_INITIALIZER_DELEGATING:
8846 TInfo = readTypeSourceInfo();
8847 break;
8848
8849 case CTOR_INITIALIZER_MEMBER:
8850 Member = readDeclAs<FieldDecl>();
8851 break;
8852
8853 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8854 IndirectMember = readDeclAs<IndirectFieldDecl>();
8855 break;
8856 }
8857
8858 SourceLocation MemberOrEllipsisLoc = readSourceLocation();
8859 Expr *Init = readExpr();
8860 SourceLocation LParenLoc = readSourceLocation();
8861 SourceLocation RParenLoc = readSourceLocation();
8862
8863 CXXCtorInitializer *BOMInit;
8864 if (Type == CTOR_INITIALIZER_BASE)
8865 BOMInit = new (Context)
8866 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8867 RParenLoc, MemberOrEllipsisLoc);
8868 else if (Type == CTOR_INITIALIZER_DELEGATING)
8869 BOMInit = new (Context)
8870 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8871 else if (Member)
8872 BOMInit = new (Context)
8873 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8874 Init, RParenLoc);
8875 else
8876 BOMInit = new (Context)
8877 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8878 LParenLoc, Init, RParenLoc);
8879
8880 if (/*IsWritten*/readBool()) {
8881 unsigned SourceOrder = readInt();
8882 BOMInit->setSourceOrder(SourceOrder);
8883 }
8884
8885 CtorInitializers[i] = BOMInit;
8886 }
8887
8888 return CtorInitializers;
8889 }
8890
8891 NestedNameSpecifierLoc
readNestedNameSpecifierLoc()8892 ASTRecordReader::readNestedNameSpecifierLoc() {
8893 ASTContext &Context = getContext();
8894 unsigned N = readInt();
8895 NestedNameSpecifierLocBuilder Builder;
8896 for (unsigned I = 0; I != N; ++I) {
8897 auto Kind = readNestedNameSpecifierKind();
8898 switch (Kind) {
8899 case NestedNameSpecifier::Identifier: {
8900 IdentifierInfo *II = readIdentifier();
8901 SourceRange Range = readSourceRange();
8902 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8903 break;
8904 }
8905
8906 case NestedNameSpecifier::Namespace: {
8907 NamespaceDecl *NS = readDeclAs<NamespaceDecl>();
8908 SourceRange Range = readSourceRange();
8909 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8910 break;
8911 }
8912
8913 case NestedNameSpecifier::NamespaceAlias: {
8914 NamespaceAliasDecl *Alias = readDeclAs<NamespaceAliasDecl>();
8915 SourceRange Range = readSourceRange();
8916 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8917 break;
8918 }
8919
8920 case NestedNameSpecifier::TypeSpec:
8921 case NestedNameSpecifier::TypeSpecWithTemplate: {
8922 bool Template = readBool();
8923 TypeSourceInfo *T = readTypeSourceInfo();
8924 if (!T)
8925 return NestedNameSpecifierLoc();
8926 SourceLocation ColonColonLoc = readSourceLocation();
8927
8928 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8929 Builder.Extend(Context,
8930 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8931 T->getTypeLoc(), ColonColonLoc);
8932 break;
8933 }
8934
8935 case NestedNameSpecifier::Global: {
8936 SourceLocation ColonColonLoc = readSourceLocation();
8937 Builder.MakeGlobal(Context, ColonColonLoc);
8938 break;
8939 }
8940
8941 case NestedNameSpecifier::Super: {
8942 CXXRecordDecl *RD = readDeclAs<CXXRecordDecl>();
8943 SourceRange Range = readSourceRange();
8944 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8945 break;
8946 }
8947 }
8948 }
8949
8950 return Builder.getWithLocInContext(Context);
8951 }
8952
8953 SourceRange
ReadSourceRange(ModuleFile & F,const RecordData & Record,unsigned & Idx)8954 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8955 unsigned &Idx) {
8956 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8957 SourceLocation end = ReadSourceLocation(F, Record, Idx);
8958 return SourceRange(beg, end);
8959 }
8960
8961 static FixedPointSemantics
ReadFixedPointSemantics(const SmallVectorImpl<uint64_t> & Record,unsigned & Idx)8962 ReadFixedPointSemantics(const SmallVectorImpl<uint64_t> &Record,
8963 unsigned &Idx) {
8964 unsigned Width = Record[Idx++];
8965 unsigned Scale = Record[Idx++];
8966 uint64_t Tmp = Record[Idx++];
8967 bool IsSigned = Tmp & 0x1;
8968 bool IsSaturated = Tmp & 0x2;
8969 bool HasUnsignedPadding = Tmp & 0x4;
8970 return FixedPointSemantics(Width, Scale, IsSigned, IsSaturated,
8971 HasUnsignedPadding);
8972 }
8973
8974 static const llvm::fltSemantics &
readAPFloatSemantics(ASTRecordReader & reader)8975 readAPFloatSemantics(ASTRecordReader &reader) {
8976 return llvm::APFloatBase::EnumToSemantics(
8977 static_cast<llvm::APFloatBase::Semantics>(reader.readInt()));
8978 }
8979
readAPValue()8980 APValue ASTRecordReader::readAPValue() {
8981 unsigned Kind = readInt();
8982 switch ((APValue::ValueKind) Kind) {
8983 case APValue::None:
8984 return APValue();
8985 case APValue::Indeterminate:
8986 return APValue::IndeterminateValue();
8987 case APValue::Int:
8988 return APValue(readAPSInt());
8989 case APValue::Float: {
8990 const llvm::fltSemantics &FloatSema = readAPFloatSemantics(*this);
8991 return APValue(readAPFloat(FloatSema));
8992 }
8993 case APValue::FixedPoint: {
8994 FixedPointSemantics FPSema = ReadFixedPointSemantics(Record, Idx);
8995 return APValue(APFixedPoint(readAPInt(), FPSema));
8996 }
8997 case APValue::ComplexInt: {
8998 llvm::APSInt First = readAPSInt();
8999 return APValue(std::move(First), readAPSInt());
9000 }
9001 case APValue::ComplexFloat: {
9002 const llvm::fltSemantics &FloatSema1 = readAPFloatSemantics(*this);
9003 llvm::APFloat First = readAPFloat(FloatSema1);
9004 const llvm::fltSemantics &FloatSema2 = readAPFloatSemantics(*this);
9005 return APValue(std::move(First), readAPFloat(FloatSema2));
9006 }
9007 case APValue::LValue:
9008 case APValue::Vector:
9009 case APValue::Array:
9010 case APValue::Struct:
9011 case APValue::Union:
9012 case APValue::MemberPointer:
9013 case APValue::AddrLabelDiff:
9014 // TODO : Handle all these APValue::ValueKind.
9015 return APValue();
9016 }
9017 llvm_unreachable("Invalid APValue::ValueKind");
9018 }
9019
9020 /// Read a floating-point value
readAPFloat(const llvm::fltSemantics & Sem)9021 llvm::APFloat ASTRecordReader::readAPFloat(const llvm::fltSemantics &Sem) {
9022 return llvm::APFloat(Sem, readAPInt());
9023 }
9024
9025 // Read a string
ReadString(const RecordData & Record,unsigned & Idx)9026 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9027 unsigned Len = Record[Idx++];
9028 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9029 Idx += Len;
9030 return Result;
9031 }
9032
ReadPath(ModuleFile & F,const RecordData & Record,unsigned & Idx)9033 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9034 unsigned &Idx) {
9035 std::string Filename = ReadString(Record, Idx);
9036 ResolveImportedPath(F, Filename);
9037 return Filename;
9038 }
9039
ReadPath(StringRef BaseDirectory,const RecordData & Record,unsigned & Idx)9040 std::string ASTReader::ReadPath(StringRef BaseDirectory,
9041 const RecordData &Record, unsigned &Idx) {
9042 std::string Filename = ReadString(Record, Idx);
9043 if (!BaseDirectory.empty())
9044 ResolveImportedPath(Filename, BaseDirectory);
9045 return Filename;
9046 }
9047
ReadVersionTuple(const RecordData & Record,unsigned & Idx)9048 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9049 unsigned &Idx) {
9050 unsigned Major = Record[Idx++];
9051 unsigned Minor = Record[Idx++];
9052 unsigned Subminor = Record[Idx++];
9053 if (Minor == 0)
9054 return VersionTuple(Major);
9055 if (Subminor == 0)
9056 return VersionTuple(Major, Minor - 1);
9057 return VersionTuple(Major, Minor - 1, Subminor - 1);
9058 }
9059
ReadCXXTemporary(ModuleFile & F,const RecordData & Record,unsigned & Idx)9060 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9061 const RecordData &Record,
9062 unsigned &Idx) {
9063 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9064 return CXXTemporary::Create(getContext(), Decl);
9065 }
9066
Diag(unsigned DiagID) const9067 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9068 return Diag(CurrentImportLoc, DiagID);
9069 }
9070
Diag(SourceLocation Loc,unsigned DiagID) const9071 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9072 return Diags.Report(Loc, DiagID);
9073 }
9074
9075 /// Retrieve the identifier table associated with the
9076 /// preprocessor.
getIdentifierTable()9077 IdentifierTable &ASTReader::getIdentifierTable() {
9078 return PP.getIdentifierTable();
9079 }
9080
9081 /// Record that the given ID maps to the given switch-case
9082 /// statement.
RecordSwitchCaseID(SwitchCase * SC,unsigned ID)9083 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9084 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
9085 "Already have a SwitchCase with this ID");
9086 (*CurrSwitchCaseStmts)[ID] = SC;
9087 }
9088
9089 /// Retrieve the switch-case statement with the given ID.
getSwitchCaseWithID(unsigned ID)9090 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9091 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
9092 return (*CurrSwitchCaseStmts)[ID];
9093 }
9094
ClearSwitchCaseIDs()9095 void ASTReader::ClearSwitchCaseIDs() {
9096 CurrSwitchCaseStmts->clear();
9097 }
9098
ReadComments()9099 void ASTReader::ReadComments() {
9100 ASTContext &Context = getContext();
9101 std::vector<RawComment *> Comments;
9102 for (SmallVectorImpl<std::pair<BitstreamCursor,
9103 serialization::ModuleFile *>>::iterator
9104 I = CommentsCursors.begin(),
9105 E = CommentsCursors.end();
9106 I != E; ++I) {
9107 Comments.clear();
9108 BitstreamCursor &Cursor = I->first;
9109 serialization::ModuleFile &F = *I->second;
9110 SavedStreamPosition SavedPosition(Cursor);
9111
9112 RecordData Record;
9113 while (true) {
9114 Expected<llvm::BitstreamEntry> MaybeEntry =
9115 Cursor.advanceSkippingSubblocks(
9116 BitstreamCursor::AF_DontPopBlockAtEnd);
9117 if (!MaybeEntry) {
9118 Error(MaybeEntry.takeError());
9119 return;
9120 }
9121 llvm::BitstreamEntry Entry = MaybeEntry.get();
9122
9123 switch (Entry.Kind) {
9124 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9125 case llvm::BitstreamEntry::Error:
9126 Error("malformed block record in AST file");
9127 return;
9128 case llvm::BitstreamEntry::EndBlock:
9129 goto NextCursor;
9130 case llvm::BitstreamEntry::Record:
9131 // The interesting case.
9132 break;
9133 }
9134
9135 // Read a record.
9136 Record.clear();
9137 Expected<unsigned> MaybeComment = Cursor.readRecord(Entry.ID, Record);
9138 if (!MaybeComment) {
9139 Error(MaybeComment.takeError());
9140 return;
9141 }
9142 switch ((CommentRecordTypes)MaybeComment.get()) {
9143 case COMMENTS_RAW_COMMENT: {
9144 unsigned Idx = 0;
9145 SourceRange SR = ReadSourceRange(F, Record, Idx);
9146 RawComment::CommentKind Kind =
9147 (RawComment::CommentKind) Record[Idx++];
9148 bool IsTrailingComment = Record[Idx++];
9149 bool IsAlmostTrailingComment = Record[Idx++];
9150 Comments.push_back(new (Context) RawComment(
9151 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9152 break;
9153 }
9154 }
9155 }
9156 NextCursor:
9157 llvm::DenseMap<FileID, std::map<unsigned, RawComment *>>
9158 FileToOffsetToComment;
9159 for (RawComment *C : Comments) {
9160 SourceLocation CommentLoc = C->getBeginLoc();
9161 if (CommentLoc.isValid()) {
9162 std::pair<FileID, unsigned> Loc =
9163 SourceMgr.getDecomposedLoc(CommentLoc);
9164 if (Loc.first.isValid())
9165 Context.Comments.OrderedComments[Loc.first].emplace(Loc.second, C);
9166 }
9167 }
9168 }
9169 }
9170
visitInputFiles(serialization::ModuleFile & MF,bool IncludeSystem,bool Complain,llvm::function_ref<void (const serialization::InputFile & IF,bool isSystem)> Visitor)9171 void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9172 bool IncludeSystem, bool Complain,
9173 llvm::function_ref<void(const serialization::InputFile &IF,
9174 bool isSystem)> Visitor) {
9175 unsigned NumUserInputs = MF.NumUserInputFiles;
9176 unsigned NumInputs = MF.InputFilesLoaded.size();
9177 assert(NumUserInputs <= NumInputs);
9178 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9179 for (unsigned I = 0; I < N; ++I) {
9180 bool IsSystem = I >= NumUserInputs;
9181 InputFile IF = getInputFile(MF, I+1, Complain);
9182 Visitor(IF, IsSystem);
9183 }
9184 }
9185
visitTopLevelModuleMaps(serialization::ModuleFile & MF,llvm::function_ref<void (const FileEntry * FE)> Visitor)9186 void ASTReader::visitTopLevelModuleMaps(
9187 serialization::ModuleFile &MF,
9188 llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9189 unsigned NumInputs = MF.InputFilesLoaded.size();
9190 for (unsigned I = 0; I < NumInputs; ++I) {
9191 InputFileInfo IFI = readInputFileInfo(MF, I + 1);
9192 if (IFI.TopLevelModuleMap)
9193 // FIXME: This unnecessarily re-reads the InputFileInfo.
9194 if (auto *FE = getInputFile(MF, I + 1).getFile())
9195 Visitor(FE);
9196 }
9197 }
9198
getOwningModuleNameForDiagnostic(const Decl * D)9199 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
9200 // If we know the owning module, use it.
9201 if (Module *M = D->getImportedOwningModule())
9202 return M->getFullModuleName();
9203
9204 // Otherwise, use the name of the top-level module the decl is within.
9205 if (ModuleFile *M = getOwningModuleFile(D))
9206 return M->ModuleName;
9207
9208 // Not from a module.
9209 return {};
9210 }
9211
finishPendingActions()9212 void ASTReader::finishPendingActions() {
9213 while (!PendingIdentifierInfos.empty() || !PendingFunctionTypes.empty() ||
9214 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9215 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9216 !PendingUpdateRecords.empty()) {
9217 // If any identifiers with corresponding top-level declarations have
9218 // been loaded, load those declarations now.
9219 using TopLevelDeclsMap =
9220 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9221 TopLevelDeclsMap TopLevelDecls;
9222
9223 while (!PendingIdentifierInfos.empty()) {
9224 IdentifierInfo *II = PendingIdentifierInfos.back().first;
9225 SmallVector<uint32_t, 4> DeclIDs =
9226 std::move(PendingIdentifierInfos.back().second);
9227 PendingIdentifierInfos.pop_back();
9228
9229 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9230 }
9231
9232 // Load each function type that we deferred loading because it was a
9233 // deduced type that might refer to a local type declared within itself.
9234 for (unsigned I = 0; I != PendingFunctionTypes.size(); ++I) {
9235 auto *FD = PendingFunctionTypes[I].first;
9236 FD->setType(GetType(PendingFunctionTypes[I].second));
9237
9238 // If we gave a function a deduced return type, remember that we need to
9239 // propagate that along the redeclaration chain.
9240 auto *DT = FD->getReturnType()->getContainedDeducedType();
9241 if (DT && DT->isDeduced())
9242 PendingDeducedTypeUpdates.insert(
9243 {FD->getCanonicalDecl(), FD->getReturnType()});
9244 }
9245 PendingFunctionTypes.clear();
9246
9247 // For each decl chain that we wanted to complete while deserializing, mark
9248 // it as "still needs to be completed".
9249 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9250 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9251 }
9252 PendingIncompleteDeclChains.clear();
9253
9254 // Load pending declaration chains.
9255 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9256 loadPendingDeclChain(PendingDeclChains[I].first,
9257 PendingDeclChains[I].second);
9258 PendingDeclChains.clear();
9259
9260 // Make the most recent of the top-level declarations visible.
9261 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9262 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9263 IdentifierInfo *II = TLD->first;
9264 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9265 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9266 }
9267 }
9268
9269 // Load any pending macro definitions.
9270 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9271 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9272 SmallVector<PendingMacroInfo, 2> GlobalIDs;
9273 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9274 // Initialize the macro history from chained-PCHs ahead of module imports.
9275 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9276 ++IDIdx) {
9277 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9278 if (!Info.M->isModule())
9279 resolvePendingMacro(II, Info);
9280 }
9281 // Handle module imports.
9282 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9283 ++IDIdx) {
9284 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9285 if (Info.M->isModule())
9286 resolvePendingMacro(II, Info);
9287 }
9288 }
9289 PendingMacroIDs.clear();
9290
9291 // Wire up the DeclContexts for Decls that we delayed setting until
9292 // recursive loading is completed.
9293 while (!PendingDeclContextInfos.empty()) {
9294 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9295 PendingDeclContextInfos.pop_front();
9296 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9297 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9298 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9299 }
9300
9301 // Perform any pending declaration updates.
9302 while (!PendingUpdateRecords.empty()) {
9303 auto Update = PendingUpdateRecords.pop_back_val();
9304 ReadingKindTracker ReadingKind(Read_Decl, *this);
9305 loadDeclUpdateRecords(Update);
9306 }
9307 }
9308
9309 // At this point, all update records for loaded decls are in place, so any
9310 // fake class definitions should have become real.
9311 assert(PendingFakeDefinitionData.empty() &&
9312 "faked up a class definition but never saw the real one");
9313
9314 // If we deserialized any C++ or Objective-C class definitions, any
9315 // Objective-C protocol definitions, or any redeclarable templates, make sure
9316 // that all redeclarations point to the definitions. Note that this can only
9317 // happen now, after the redeclaration chains have been fully wired.
9318 for (Decl *D : PendingDefinitions) {
9319 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9320 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9321 // Make sure that the TagType points at the definition.
9322 const_cast<TagType*>(TagT)->decl = TD;
9323 }
9324
9325 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9326 for (auto *R = getMostRecentExistingDecl(RD); R;
9327 R = R->getPreviousDecl()) {
9328 assert((R == D) ==
9329 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
9330 "declaration thinks it's the definition but it isn't");
9331 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9332 }
9333 }
9334
9335 continue;
9336 }
9337
9338 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9339 // Make sure that the ObjCInterfaceType points at the definition.
9340 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9341 ->Decl = ID;
9342
9343 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9344 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9345
9346 continue;
9347 }
9348
9349 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9350 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9351 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9352
9353 continue;
9354 }
9355
9356 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9357 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9358 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9359 }
9360 PendingDefinitions.clear();
9361
9362 // Load the bodies of any functions or methods we've encountered. We do
9363 // this now (delayed) so that we can be sure that the declaration chains
9364 // have been fully wired up (hasBody relies on this).
9365 // FIXME: We shouldn't require complete redeclaration chains here.
9366 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9367 PBEnd = PendingBodies.end();
9368 PB != PBEnd; ++PB) {
9369 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9370 // For a function defined inline within a class template, force the
9371 // canonical definition to be the one inside the canonical definition of
9372 // the template. This ensures that we instantiate from a correct view
9373 // of the template.
9374 //
9375 // Sadly we can't do this more generally: we can't be sure that all
9376 // copies of an arbitrary class definition will have the same members
9377 // defined (eg, some member functions may not be instantiated, and some
9378 // special members may or may not have been implicitly defined).
9379 if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9380 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9381 continue;
9382
9383 // FIXME: Check for =delete/=default?
9384 // FIXME: Complain about ODR violations here?
9385 const FunctionDecl *Defn = nullptr;
9386 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9387 FD->setLazyBody(PB->second);
9388 } else {
9389 auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9390 mergeDefinitionVisibility(NonConstDefn, FD);
9391
9392 if (!FD->isLateTemplateParsed() &&
9393 !NonConstDefn->isLateTemplateParsed() &&
9394 FD->getODRHash() != NonConstDefn->getODRHash()) {
9395 if (!isa<CXXMethodDecl>(FD)) {
9396 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9397 } else if (FD->getLexicalParent()->isFileContext() &&
9398 NonConstDefn->getLexicalParent()->isFileContext()) {
9399 // Only diagnose out-of-line method definitions. If they are
9400 // in class definitions, then an error will be generated when
9401 // processing the class bodies.
9402 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9403 }
9404 }
9405 }
9406 continue;
9407 }
9408
9409 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9410 if (!getContext().getLangOpts().Modules || !MD->hasBody())
9411 MD->setLazyBody(PB->second);
9412 }
9413 PendingBodies.clear();
9414
9415 // Do some cleanup.
9416 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9417 getContext().deduplicateMergedDefinitonsFor(ND);
9418 PendingMergedDefinitionsToDeduplicate.clear();
9419 }
9420
diagnoseOdrViolations()9421 void ASTReader::diagnoseOdrViolations() {
9422 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9423 PendingFunctionOdrMergeFailures.empty() &&
9424 PendingEnumOdrMergeFailures.empty())
9425 return;
9426
9427 // Trigger the import of the full definition of each class that had any
9428 // odr-merging problems, so we can produce better diagnostics for them.
9429 // These updates may in turn find and diagnose some ODR failures, so take
9430 // ownership of the set first.
9431 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9432 PendingOdrMergeFailures.clear();
9433 for (auto &Merge : OdrMergeFailures) {
9434 Merge.first->buildLookup();
9435 Merge.first->decls_begin();
9436 Merge.first->bases_begin();
9437 Merge.first->vbases_begin();
9438 for (auto &RecordPair : Merge.second) {
9439 auto *RD = RecordPair.first;
9440 RD->decls_begin();
9441 RD->bases_begin();
9442 RD->vbases_begin();
9443 }
9444 }
9445
9446 // Trigger the import of functions.
9447 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9448 PendingFunctionOdrMergeFailures.clear();
9449 for (auto &Merge : FunctionOdrMergeFailures) {
9450 Merge.first->buildLookup();
9451 Merge.first->decls_begin();
9452 Merge.first->getBody();
9453 for (auto &FD : Merge.second) {
9454 FD->buildLookup();
9455 FD->decls_begin();
9456 FD->getBody();
9457 }
9458 }
9459
9460 // Trigger the import of enums.
9461 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9462 PendingEnumOdrMergeFailures.clear();
9463 for (auto &Merge : EnumOdrMergeFailures) {
9464 Merge.first->decls_begin();
9465 for (auto &Enum : Merge.second) {
9466 Enum->decls_begin();
9467 }
9468 }
9469
9470 // For each declaration from a merged context, check that the canonical
9471 // definition of that context also contains a declaration of the same
9472 // entity.
9473 //
9474 // Caution: this loop does things that might invalidate iterators into
9475 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9476 while (!PendingOdrMergeChecks.empty()) {
9477 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9478
9479 // FIXME: Skip over implicit declarations for now. This matters for things
9480 // like implicitly-declared special member functions. This isn't entirely
9481 // correct; we can end up with multiple unmerged declarations of the same
9482 // implicit entity.
9483 if (D->isImplicit())
9484 continue;
9485
9486 DeclContext *CanonDef = D->getDeclContext();
9487
9488 bool Found = false;
9489 const Decl *DCanon = D->getCanonicalDecl();
9490
9491 for (auto RI : D->redecls()) {
9492 if (RI->getLexicalDeclContext() == CanonDef) {
9493 Found = true;
9494 break;
9495 }
9496 }
9497 if (Found)
9498 continue;
9499
9500 // Quick check failed, time to do the slow thing. Note, we can't just
9501 // look up the name of D in CanonDef here, because the member that is
9502 // in CanonDef might not be found by name lookup (it might have been
9503 // replaced by a more recent declaration in the lookup table), and we
9504 // can't necessarily find it in the redeclaration chain because it might
9505 // be merely mergeable, not redeclarable.
9506 llvm::SmallVector<const NamedDecl*, 4> Candidates;
9507 for (auto *CanonMember : CanonDef->decls()) {
9508 if (CanonMember->getCanonicalDecl() == DCanon) {
9509 // This can happen if the declaration is merely mergeable and not
9510 // actually redeclarable (we looked for redeclarations earlier).
9511 //
9512 // FIXME: We should be able to detect this more efficiently, without
9513 // pulling in all of the members of CanonDef.
9514 Found = true;
9515 break;
9516 }
9517 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9518 if (ND->getDeclName() == D->getDeclName())
9519 Candidates.push_back(ND);
9520 }
9521
9522 if (!Found) {
9523 // The AST doesn't like TagDecls becoming invalid after they've been
9524 // completed. We only really need to mark FieldDecls as invalid here.
9525 if (!isa<TagDecl>(D))
9526 D->setInvalidDecl();
9527
9528 // Ensure we don't accidentally recursively enter deserialization while
9529 // we're producing our diagnostic.
9530 Deserializing RecursionGuard(this);
9531
9532 std::string CanonDefModule =
9533 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9534 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9535 << D << getOwningModuleNameForDiagnostic(D)
9536 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9537
9538 if (Candidates.empty())
9539 Diag(cast<Decl>(CanonDef)->getLocation(),
9540 diag::note_module_odr_violation_no_possible_decls) << D;
9541 else {
9542 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9543 Diag(Candidates[I]->getLocation(),
9544 diag::note_module_odr_violation_possible_decl)
9545 << Candidates[I];
9546 }
9547
9548 DiagnosedOdrMergeFailures.insert(CanonDef);
9549 }
9550 }
9551
9552 if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9553 EnumOdrMergeFailures.empty())
9554 return;
9555
9556 // Ensure we don't accidentally recursively enter deserialization while
9557 // we're producing our diagnostics.
9558 Deserializing RecursionGuard(this);
9559
9560 // Common code for hashing helpers.
9561 ODRHash Hash;
9562 auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9563 Hash.clear();
9564 Hash.AddQualType(Ty);
9565 return Hash.CalculateHash();
9566 };
9567
9568 auto ComputeODRHash = [&Hash](const Stmt *S) {
9569 assert(S);
9570 Hash.clear();
9571 Hash.AddStmt(S);
9572 return Hash.CalculateHash();
9573 };
9574
9575 auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9576 assert(D);
9577 Hash.clear();
9578 Hash.AddSubDecl(D);
9579 return Hash.CalculateHash();
9580 };
9581
9582 auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9583 Hash.clear();
9584 Hash.AddTemplateArgument(TA);
9585 return Hash.CalculateHash();
9586 };
9587
9588 auto ComputeTemplateParameterListODRHash =
9589 [&Hash](const TemplateParameterList *TPL) {
9590 assert(TPL);
9591 Hash.clear();
9592 Hash.AddTemplateParameterList(TPL);
9593 return Hash.CalculateHash();
9594 };
9595
9596 // Used with err_module_odr_violation_mismatch_decl and
9597 // note_module_odr_violation_mismatch_decl
9598 // This list should be the same Decl's as in ODRHash::isDeclToBeProcessed
9599 enum ODRMismatchDecl {
9600 EndOfClass,
9601 PublicSpecifer,
9602 PrivateSpecifer,
9603 ProtectedSpecifer,
9604 StaticAssert,
9605 Field,
9606 CXXMethod,
9607 TypeAlias,
9608 TypeDef,
9609 Var,
9610 Friend,
9611 FunctionTemplate,
9612 Other
9613 };
9614
9615 // Used with err_module_odr_violation_mismatch_decl_diff and
9616 // note_module_odr_violation_mismatch_decl_diff
9617 enum ODRMismatchDeclDifference {
9618 StaticAssertCondition,
9619 StaticAssertMessage,
9620 StaticAssertOnlyMessage,
9621 FieldName,
9622 FieldTypeName,
9623 FieldSingleBitField,
9624 FieldDifferentWidthBitField,
9625 FieldSingleMutable,
9626 FieldSingleInitializer,
9627 FieldDifferentInitializers,
9628 MethodName,
9629 MethodDeleted,
9630 MethodDefaulted,
9631 MethodVirtual,
9632 MethodStatic,
9633 MethodVolatile,
9634 MethodConst,
9635 MethodInline,
9636 MethodNumberParameters,
9637 MethodParameterType,
9638 MethodParameterName,
9639 MethodParameterSingleDefaultArgument,
9640 MethodParameterDifferentDefaultArgument,
9641 MethodNoTemplateArguments,
9642 MethodDifferentNumberTemplateArguments,
9643 MethodDifferentTemplateArgument,
9644 MethodSingleBody,
9645 MethodDifferentBody,
9646 TypedefName,
9647 TypedefType,
9648 VarName,
9649 VarType,
9650 VarSingleInitializer,
9651 VarDifferentInitializer,
9652 VarConstexpr,
9653 FriendTypeFunction,
9654 FriendType,
9655 FriendFunction,
9656 FunctionTemplateDifferentNumberParameters,
9657 FunctionTemplateParameterDifferentKind,
9658 FunctionTemplateParameterName,
9659 FunctionTemplateParameterSingleDefaultArgument,
9660 FunctionTemplateParameterDifferentDefaultArgument,
9661 FunctionTemplateParameterDifferentType,
9662 FunctionTemplatePackParameter,
9663 };
9664
9665 // These lambdas have the common portions of the ODR diagnostics. This
9666 // has the same return as Diag(), so addition parameters can be passed
9667 // in with operator<<
9668 auto ODRDiagDeclError = [this](NamedDecl *FirstRecord, StringRef FirstModule,
9669 SourceLocation Loc, SourceRange Range,
9670 ODRMismatchDeclDifference DiffType) {
9671 return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
9672 << FirstRecord << FirstModule.empty() << FirstModule << Range
9673 << DiffType;
9674 };
9675 auto ODRDiagDeclNote = [this](StringRef SecondModule, SourceLocation Loc,
9676 SourceRange Range, ODRMismatchDeclDifference DiffType) {
9677 return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
9678 << SecondModule << Range << DiffType;
9679 };
9680
9681 auto ODRDiagField = [this, &ODRDiagDeclError, &ODRDiagDeclNote,
9682 &ComputeQualTypeODRHash, &ComputeODRHash](
9683 NamedDecl *FirstRecord, StringRef FirstModule,
9684 StringRef SecondModule, FieldDecl *FirstField,
9685 FieldDecl *SecondField) {
9686 IdentifierInfo *FirstII = FirstField->getIdentifier();
9687 IdentifierInfo *SecondII = SecondField->getIdentifier();
9688 if (FirstII->getName() != SecondII->getName()) {
9689 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9690 FirstField->getSourceRange(), FieldName)
9691 << FirstII;
9692 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9693 SecondField->getSourceRange(), FieldName)
9694 << SecondII;
9695
9696 return true;
9697 }
9698
9699 assert(getContext().hasSameType(FirstField->getType(),
9700 SecondField->getType()));
9701
9702 QualType FirstType = FirstField->getType();
9703 QualType SecondType = SecondField->getType();
9704 if (ComputeQualTypeODRHash(FirstType) !=
9705 ComputeQualTypeODRHash(SecondType)) {
9706 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9707 FirstField->getSourceRange(), FieldTypeName)
9708 << FirstII << FirstType;
9709 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9710 SecondField->getSourceRange(), FieldTypeName)
9711 << SecondII << SecondType;
9712
9713 return true;
9714 }
9715
9716 const bool IsFirstBitField = FirstField->isBitField();
9717 const bool IsSecondBitField = SecondField->isBitField();
9718 if (IsFirstBitField != IsSecondBitField) {
9719 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9720 FirstField->getSourceRange(), FieldSingleBitField)
9721 << FirstII << IsFirstBitField;
9722 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9723 SecondField->getSourceRange(), FieldSingleBitField)
9724 << SecondII << IsSecondBitField;
9725 return true;
9726 }
9727
9728 if (IsFirstBitField && IsSecondBitField) {
9729 unsigned FirstBitWidthHash =
9730 ComputeODRHash(FirstField->getBitWidth());
9731 unsigned SecondBitWidthHash =
9732 ComputeODRHash(SecondField->getBitWidth());
9733 if (FirstBitWidthHash != SecondBitWidthHash) {
9734 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9735 FirstField->getSourceRange(),
9736 FieldDifferentWidthBitField)
9737 << FirstII << FirstField->getBitWidth()->getSourceRange();
9738 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9739 SecondField->getSourceRange(),
9740 FieldDifferentWidthBitField)
9741 << SecondII << SecondField->getBitWidth()->getSourceRange();
9742 return true;
9743 }
9744 }
9745
9746 if (!PP.getLangOpts().CPlusPlus)
9747 return false;
9748
9749 const bool IsFirstMutable = FirstField->isMutable();
9750 const bool IsSecondMutable = SecondField->isMutable();
9751 if (IsFirstMutable != IsSecondMutable) {
9752 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9753 FirstField->getSourceRange(), FieldSingleMutable)
9754 << FirstII << IsFirstMutable;
9755 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9756 SecondField->getSourceRange(), FieldSingleMutable)
9757 << SecondII << IsSecondMutable;
9758 return true;
9759 }
9760
9761 const Expr *FirstInitializer = FirstField->getInClassInitializer();
9762 const Expr *SecondInitializer = SecondField->getInClassInitializer();
9763 if ((!FirstInitializer && SecondInitializer) ||
9764 (FirstInitializer && !SecondInitializer)) {
9765 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9766 FirstField->getSourceRange(), FieldSingleInitializer)
9767 << FirstII << (FirstInitializer != nullptr);
9768 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9769 SecondField->getSourceRange(), FieldSingleInitializer)
9770 << SecondII << (SecondInitializer != nullptr);
9771 return true;
9772 }
9773
9774 if (FirstInitializer && SecondInitializer) {
9775 unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
9776 unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
9777 if (FirstInitHash != SecondInitHash) {
9778 ODRDiagDeclError(FirstRecord, FirstModule, FirstField->getLocation(),
9779 FirstField->getSourceRange(),
9780 FieldDifferentInitializers)
9781 << FirstII << FirstInitializer->getSourceRange();
9782 ODRDiagDeclNote(SecondModule, SecondField->getLocation(),
9783 SecondField->getSourceRange(),
9784 FieldDifferentInitializers)
9785 << SecondII << SecondInitializer->getSourceRange();
9786 return true;
9787 }
9788 }
9789
9790 return false;
9791 };
9792
9793 auto ODRDiagTypeDefOrAlias =
9794 [&ODRDiagDeclError, &ODRDiagDeclNote, &ComputeQualTypeODRHash](
9795 NamedDecl *FirstRecord, StringRef FirstModule, StringRef SecondModule,
9796 TypedefNameDecl *FirstTD, TypedefNameDecl *SecondTD,
9797 bool IsTypeAlias) {
9798 auto FirstName = FirstTD->getDeclName();
9799 auto SecondName = SecondTD->getDeclName();
9800 if (FirstName != SecondName) {
9801 ODRDiagDeclError(FirstRecord, FirstModule, FirstTD->getLocation(),
9802 FirstTD->getSourceRange(), TypedefName)
9803 << IsTypeAlias << FirstName;
9804 ODRDiagDeclNote(SecondModule, SecondTD->getLocation(),
9805 SecondTD->getSourceRange(), TypedefName)
9806 << IsTypeAlias << SecondName;
9807 return true;
9808 }
9809
9810 QualType FirstType = FirstTD->getUnderlyingType();
9811 QualType SecondType = SecondTD->getUnderlyingType();
9812 if (ComputeQualTypeODRHash(FirstType) !=
9813 ComputeQualTypeODRHash(SecondType)) {
9814 ODRDiagDeclError(FirstRecord, FirstModule, FirstTD->getLocation(),
9815 FirstTD->getSourceRange(), TypedefType)
9816 << IsTypeAlias << FirstName << FirstType;
9817 ODRDiagDeclNote(SecondModule, SecondTD->getLocation(),
9818 SecondTD->getSourceRange(), TypedefType)
9819 << IsTypeAlias << SecondName << SecondType;
9820 return true;
9821 }
9822
9823 return false;
9824 };
9825
9826 auto ODRDiagVar = [&ODRDiagDeclError, &ODRDiagDeclNote,
9827 &ComputeQualTypeODRHash, &ComputeODRHash,
9828 this](NamedDecl *FirstRecord, StringRef FirstModule,
9829 StringRef SecondModule, VarDecl *FirstVD,
9830 VarDecl *SecondVD) {
9831 auto FirstName = FirstVD->getDeclName();
9832 auto SecondName = SecondVD->getDeclName();
9833 if (FirstName != SecondName) {
9834 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9835 FirstVD->getSourceRange(), VarName)
9836 << FirstName;
9837 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9838 SecondVD->getSourceRange(), VarName)
9839 << SecondName;
9840 return true;
9841 }
9842
9843 QualType FirstType = FirstVD->getType();
9844 QualType SecondType = SecondVD->getType();
9845 if (ComputeQualTypeODRHash(FirstType) !=
9846 ComputeQualTypeODRHash(SecondType)) {
9847 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9848 FirstVD->getSourceRange(), VarType)
9849 << FirstName << FirstType;
9850 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9851 SecondVD->getSourceRange(), VarType)
9852 << SecondName << SecondType;
9853 return true;
9854 }
9855
9856 if (!PP.getLangOpts().CPlusPlus)
9857 return false;
9858
9859 const Expr *FirstInit = FirstVD->getInit();
9860 const Expr *SecondInit = SecondVD->getInit();
9861 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
9862 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9863 FirstVD->getSourceRange(), VarSingleInitializer)
9864 << FirstName << (FirstInit == nullptr)
9865 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
9866 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9867 SecondVD->getSourceRange(), VarSingleInitializer)
9868 << SecondName << (SecondInit == nullptr)
9869 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
9870 return true;
9871 }
9872
9873 if (FirstInit && SecondInit &&
9874 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
9875 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9876 FirstVD->getSourceRange(), VarDifferentInitializer)
9877 << FirstName << FirstInit->getSourceRange();
9878 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9879 SecondVD->getSourceRange(), VarDifferentInitializer)
9880 << SecondName << SecondInit->getSourceRange();
9881 return true;
9882 }
9883
9884 const bool FirstIsConstexpr = FirstVD->isConstexpr();
9885 const bool SecondIsConstexpr = SecondVD->isConstexpr();
9886 if (FirstIsConstexpr != SecondIsConstexpr) {
9887 ODRDiagDeclError(FirstRecord, FirstModule, FirstVD->getLocation(),
9888 FirstVD->getSourceRange(), VarConstexpr)
9889 << FirstName << FirstIsConstexpr;
9890 ODRDiagDeclNote(SecondModule, SecondVD->getLocation(),
9891 SecondVD->getSourceRange(), VarConstexpr)
9892 << SecondName << SecondIsConstexpr;
9893 return true;
9894 }
9895 return false;
9896 };
9897
9898 auto DifferenceSelector = [](Decl *D) {
9899 assert(D && "valid Decl required");
9900 switch (D->getKind()) {
9901 default:
9902 return Other;
9903 case Decl::AccessSpec:
9904 switch (D->getAccess()) {
9905 case AS_public:
9906 return PublicSpecifer;
9907 case AS_private:
9908 return PrivateSpecifer;
9909 case AS_protected:
9910 return ProtectedSpecifer;
9911 case AS_none:
9912 break;
9913 }
9914 llvm_unreachable("Invalid access specifier");
9915 case Decl::StaticAssert:
9916 return StaticAssert;
9917 case Decl::Field:
9918 return Field;
9919 case Decl::CXXMethod:
9920 case Decl::CXXConstructor:
9921 case Decl::CXXDestructor:
9922 return CXXMethod;
9923 case Decl::TypeAlias:
9924 return TypeAlias;
9925 case Decl::Typedef:
9926 return TypeDef;
9927 case Decl::Var:
9928 return Var;
9929 case Decl::Friend:
9930 return Friend;
9931 case Decl::FunctionTemplate:
9932 return FunctionTemplate;
9933 }
9934 };
9935
9936 using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9937 auto PopulateHashes = [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9938 RecordDecl *Record,
9939 const DeclContext *DC) {
9940 for (auto *D : Record->decls()) {
9941 if (!ODRHash::isDeclToBeProcessed(D, DC))
9942 continue;
9943 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9944 }
9945 };
9946
9947 struct DiffResult {
9948 Decl *FirstDecl = nullptr, *SecondDecl = nullptr;
9949 ODRMismatchDecl FirstDiffType = Other, SecondDiffType = Other;
9950 };
9951
9952 // If there is a diagnoseable difference, FirstDiffType and
9953 // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
9954 // filled in if not EndOfClass.
9955 auto FindTypeDiffs = [&DifferenceSelector](DeclHashes &FirstHashes,
9956 DeclHashes &SecondHashes) {
9957 DiffResult DR;
9958 auto FirstIt = FirstHashes.begin();
9959 auto SecondIt = SecondHashes.begin();
9960 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
9961 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
9962 FirstIt->second == SecondIt->second) {
9963 ++FirstIt;
9964 ++SecondIt;
9965 continue;
9966 }
9967
9968 DR.FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
9969 DR.SecondDecl =
9970 SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
9971
9972 DR.FirstDiffType =
9973 DR.FirstDecl ? DifferenceSelector(DR.FirstDecl) : EndOfClass;
9974 DR.SecondDiffType =
9975 DR.SecondDecl ? DifferenceSelector(DR.SecondDecl) : EndOfClass;
9976 return DR;
9977 }
9978 return DR;
9979 };
9980
9981 // Use this to diagnose that an unexpected Decl was encountered
9982 // or no difference was detected. This causes a generic error
9983 // message to be emitted.
9984 auto DiagnoseODRUnexpected = [this](DiffResult &DR, NamedDecl *FirstRecord,
9985 StringRef FirstModule,
9986 NamedDecl *SecondRecord,
9987 StringRef SecondModule) {
9988 Diag(FirstRecord->getLocation(),
9989 diag::err_module_odr_violation_different_definitions)
9990 << FirstRecord << FirstModule.empty() << FirstModule;
9991
9992 if (DR.FirstDecl) {
9993 Diag(DR.FirstDecl->getLocation(), diag::note_first_module_difference)
9994 << FirstRecord << DR.FirstDecl->getSourceRange();
9995 }
9996
9997 Diag(SecondRecord->getLocation(),
9998 diag::note_module_odr_violation_different_definitions)
9999 << SecondModule;
10000
10001 if (DR.SecondDecl) {
10002 Diag(DR.SecondDecl->getLocation(), diag::note_second_module_difference)
10003 << DR.SecondDecl->getSourceRange();
10004 }
10005 };
10006
10007 auto DiagnoseODRMismatch =
10008 [this](DiffResult &DR, NamedDecl *FirstRecord, StringRef FirstModule,
10009 NamedDecl *SecondRecord, StringRef SecondModule) {
10010 SourceLocation FirstLoc;
10011 SourceRange FirstRange;
10012 auto *FirstTag = dyn_cast<TagDecl>(FirstRecord);
10013 if (DR.FirstDiffType == EndOfClass && FirstTag) {
10014 FirstLoc = FirstTag->getBraceRange().getEnd();
10015 } else {
10016 FirstLoc = DR.FirstDecl->getLocation();
10017 FirstRange = DR.FirstDecl->getSourceRange();
10018 }
10019 Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
10020 << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
10021 << DR.FirstDiffType;
10022
10023 SourceLocation SecondLoc;
10024 SourceRange SecondRange;
10025 auto *SecondTag = dyn_cast<TagDecl>(SecondRecord);
10026 if (DR.SecondDiffType == EndOfClass && SecondTag) {
10027 SecondLoc = SecondTag->getBraceRange().getEnd();
10028 } else {
10029 SecondLoc = DR.SecondDecl->getLocation();
10030 SecondRange = DR.SecondDecl->getSourceRange();
10031 }
10032 Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10033 << SecondModule << SecondRange << DR.SecondDiffType;
10034 };
10035
10036 // Issue any pending ODR-failure diagnostics.
10037 for (auto &Merge : OdrMergeFailures) {
10038 // If we've already pointed out a specific problem with this class, don't
10039 // bother issuing a general "something's different" diagnostic.
10040 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
10041 continue;
10042
10043 bool Diagnosed = false;
10044 CXXRecordDecl *FirstRecord = Merge.first;
10045 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
10046 for (auto &RecordPair : Merge.second) {
10047 CXXRecordDecl *SecondRecord = RecordPair.first;
10048 // Multiple different declarations got merged together; tell the user
10049 // where they came from.
10050 if (FirstRecord == SecondRecord)
10051 continue;
10052
10053 std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
10054
10055 auto *FirstDD = FirstRecord->DefinitionData;
10056 auto *SecondDD = RecordPair.second;
10057
10058 assert(FirstDD && SecondDD && "Definitions without DefinitionData");
10059
10060 // Diagnostics from DefinitionData are emitted here.
10061 if (FirstDD != SecondDD) {
10062 enum ODRDefinitionDataDifference {
10063 NumBases,
10064 NumVBases,
10065 BaseType,
10066 BaseVirtual,
10067 BaseAccess,
10068 };
10069 auto ODRDiagBaseError = [FirstRecord, &FirstModule,
10070 this](SourceLocation Loc, SourceRange Range,
10071 ODRDefinitionDataDifference DiffType) {
10072 return Diag(Loc, diag::err_module_odr_violation_definition_data)
10073 << FirstRecord << FirstModule.empty() << FirstModule << Range
10074 << DiffType;
10075 };
10076 auto ODRDiagBaseNote = [&SecondModule,
10077 this](SourceLocation Loc, SourceRange Range,
10078 ODRDefinitionDataDifference DiffType) {
10079 return Diag(Loc, diag::note_module_odr_violation_definition_data)
10080 << SecondModule << Range << DiffType;
10081 };
10082
10083 unsigned FirstNumBases = FirstDD->NumBases;
10084 unsigned FirstNumVBases = FirstDD->NumVBases;
10085 unsigned SecondNumBases = SecondDD->NumBases;
10086 unsigned SecondNumVBases = SecondDD->NumVBases;
10087
10088 auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
10089 unsigned NumBases = DD->NumBases;
10090 if (NumBases == 0) return SourceRange();
10091 auto bases = DD->bases();
10092 return SourceRange(bases[0].getBeginLoc(),
10093 bases[NumBases - 1].getEndLoc());
10094 };
10095
10096 if (FirstNumBases != SecondNumBases) {
10097 ODRDiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
10098 NumBases)
10099 << FirstNumBases;
10100 ODRDiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
10101 NumBases)
10102 << SecondNumBases;
10103 Diagnosed = true;
10104 break;
10105 }
10106
10107 if (FirstNumVBases != SecondNumVBases) {
10108 ODRDiagBaseError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
10109 NumVBases)
10110 << FirstNumVBases;
10111 ODRDiagBaseNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
10112 NumVBases)
10113 << SecondNumVBases;
10114 Diagnosed = true;
10115 break;
10116 }
10117
10118 auto FirstBases = FirstDD->bases();
10119 auto SecondBases = SecondDD->bases();
10120 unsigned i = 0;
10121 for (i = 0; i < FirstNumBases; ++i) {
10122 auto FirstBase = FirstBases[i];
10123 auto SecondBase = SecondBases[i];
10124 if (ComputeQualTypeODRHash(FirstBase.getType()) !=
10125 ComputeQualTypeODRHash(SecondBase.getType())) {
10126 ODRDiagBaseError(FirstRecord->getLocation(),
10127 FirstBase.getSourceRange(), BaseType)
10128 << (i + 1) << FirstBase.getType();
10129 ODRDiagBaseNote(SecondRecord->getLocation(),
10130 SecondBase.getSourceRange(), BaseType)
10131 << (i + 1) << SecondBase.getType();
10132 break;
10133 }
10134
10135 if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
10136 ODRDiagBaseError(FirstRecord->getLocation(),
10137 FirstBase.getSourceRange(), BaseVirtual)
10138 << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
10139 ODRDiagBaseNote(SecondRecord->getLocation(),
10140 SecondBase.getSourceRange(), BaseVirtual)
10141 << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
10142 break;
10143 }
10144
10145 if (FirstBase.getAccessSpecifierAsWritten() !=
10146 SecondBase.getAccessSpecifierAsWritten()) {
10147 ODRDiagBaseError(FirstRecord->getLocation(),
10148 FirstBase.getSourceRange(), BaseAccess)
10149 << (i + 1) << FirstBase.getType()
10150 << (int)FirstBase.getAccessSpecifierAsWritten();
10151 ODRDiagBaseNote(SecondRecord->getLocation(),
10152 SecondBase.getSourceRange(), BaseAccess)
10153 << (i + 1) << SecondBase.getType()
10154 << (int)SecondBase.getAccessSpecifierAsWritten();
10155 break;
10156 }
10157 }
10158
10159 if (i != FirstNumBases) {
10160 Diagnosed = true;
10161 break;
10162 }
10163 }
10164
10165 const ClassTemplateDecl *FirstTemplate =
10166 FirstRecord->getDescribedClassTemplate();
10167 const ClassTemplateDecl *SecondTemplate =
10168 SecondRecord->getDescribedClassTemplate();
10169
10170 assert(!FirstTemplate == !SecondTemplate &&
10171 "Both pointers should be null or non-null");
10172
10173 enum ODRTemplateDifference {
10174 ParamEmptyName,
10175 ParamName,
10176 ParamSingleDefaultArgument,
10177 ParamDifferentDefaultArgument,
10178 };
10179
10180 if (FirstTemplate && SecondTemplate) {
10181 DeclHashes FirstTemplateHashes;
10182 DeclHashes SecondTemplateHashes;
10183
10184 auto PopulateTemplateParameterHashs =
10185 [&ComputeSubDeclODRHash](DeclHashes &Hashes,
10186 const ClassTemplateDecl *TD) {
10187 for (auto *D : TD->getTemplateParameters()->asArray()) {
10188 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
10189 }
10190 };
10191
10192 PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
10193 PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
10194
10195 assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
10196 "Number of template parameters should be equal.");
10197
10198 auto FirstIt = FirstTemplateHashes.begin();
10199 auto FirstEnd = FirstTemplateHashes.end();
10200 auto SecondIt = SecondTemplateHashes.begin();
10201 for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
10202 if (FirstIt->second == SecondIt->second)
10203 continue;
10204
10205 auto ODRDiagTemplateError = [FirstRecord, &FirstModule, this](
10206 SourceLocation Loc, SourceRange Range,
10207 ODRTemplateDifference DiffType) {
10208 return Diag(Loc, diag::err_module_odr_violation_template_parameter)
10209 << FirstRecord << FirstModule.empty() << FirstModule << Range
10210 << DiffType;
10211 };
10212 auto ODRDiagTemplateNote = [&SecondModule, this](
10213 SourceLocation Loc, SourceRange Range,
10214 ODRTemplateDifference DiffType) {
10215 return Diag(Loc, diag::note_module_odr_violation_template_parameter)
10216 << SecondModule << Range << DiffType;
10217 };
10218
10219 const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
10220 const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
10221
10222 assert(FirstDecl->getKind() == SecondDecl->getKind() &&
10223 "Parameter Decl's should be the same kind.");
10224
10225 DeclarationName FirstName = FirstDecl->getDeclName();
10226 DeclarationName SecondName = SecondDecl->getDeclName();
10227
10228 if (FirstName != SecondName) {
10229 const bool FirstNameEmpty =
10230 FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
10231 const bool SecondNameEmpty =
10232 SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
10233 assert((!FirstNameEmpty || !SecondNameEmpty) &&
10234 "Both template parameters cannot be unnamed.");
10235 ODRDiagTemplateError(FirstDecl->getLocation(),
10236 FirstDecl->getSourceRange(),
10237 FirstNameEmpty ? ParamEmptyName : ParamName)
10238 << FirstName;
10239 ODRDiagTemplateNote(SecondDecl->getLocation(),
10240 SecondDecl->getSourceRange(),
10241 SecondNameEmpty ? ParamEmptyName : ParamName)
10242 << SecondName;
10243 break;
10244 }
10245
10246 switch (FirstDecl->getKind()) {
10247 default:
10248 llvm_unreachable("Invalid template parameter type.");
10249 case Decl::TemplateTypeParm: {
10250 const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
10251 const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
10252 const bool HasFirstDefaultArgument =
10253 FirstParam->hasDefaultArgument() &&
10254 !FirstParam->defaultArgumentWasInherited();
10255 const bool HasSecondDefaultArgument =
10256 SecondParam->hasDefaultArgument() &&
10257 !SecondParam->defaultArgumentWasInherited();
10258
10259 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10260 ODRDiagTemplateError(FirstDecl->getLocation(),
10261 FirstDecl->getSourceRange(),
10262 ParamSingleDefaultArgument)
10263 << HasFirstDefaultArgument;
10264 ODRDiagTemplateNote(SecondDecl->getLocation(),
10265 SecondDecl->getSourceRange(),
10266 ParamSingleDefaultArgument)
10267 << HasSecondDefaultArgument;
10268 break;
10269 }
10270
10271 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10272 "Expecting default arguments.");
10273
10274 ODRDiagTemplateError(FirstDecl->getLocation(),
10275 FirstDecl->getSourceRange(),
10276 ParamDifferentDefaultArgument);
10277 ODRDiagTemplateNote(SecondDecl->getLocation(),
10278 SecondDecl->getSourceRange(),
10279 ParamDifferentDefaultArgument);
10280
10281 break;
10282 }
10283 case Decl::NonTypeTemplateParm: {
10284 const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
10285 const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
10286 const bool HasFirstDefaultArgument =
10287 FirstParam->hasDefaultArgument() &&
10288 !FirstParam->defaultArgumentWasInherited();
10289 const bool HasSecondDefaultArgument =
10290 SecondParam->hasDefaultArgument() &&
10291 !SecondParam->defaultArgumentWasInherited();
10292
10293 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10294 ODRDiagTemplateError(FirstDecl->getLocation(),
10295 FirstDecl->getSourceRange(),
10296 ParamSingleDefaultArgument)
10297 << HasFirstDefaultArgument;
10298 ODRDiagTemplateNote(SecondDecl->getLocation(),
10299 SecondDecl->getSourceRange(),
10300 ParamSingleDefaultArgument)
10301 << HasSecondDefaultArgument;
10302 break;
10303 }
10304
10305 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10306 "Expecting default arguments.");
10307
10308 ODRDiagTemplateError(FirstDecl->getLocation(),
10309 FirstDecl->getSourceRange(),
10310 ParamDifferentDefaultArgument);
10311 ODRDiagTemplateNote(SecondDecl->getLocation(),
10312 SecondDecl->getSourceRange(),
10313 ParamDifferentDefaultArgument);
10314
10315 break;
10316 }
10317 case Decl::TemplateTemplateParm: {
10318 const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
10319 const auto *SecondParam =
10320 cast<TemplateTemplateParmDecl>(SecondDecl);
10321 const bool HasFirstDefaultArgument =
10322 FirstParam->hasDefaultArgument() &&
10323 !FirstParam->defaultArgumentWasInherited();
10324 const bool HasSecondDefaultArgument =
10325 SecondParam->hasDefaultArgument() &&
10326 !SecondParam->defaultArgumentWasInherited();
10327
10328 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10329 ODRDiagTemplateError(FirstDecl->getLocation(),
10330 FirstDecl->getSourceRange(),
10331 ParamSingleDefaultArgument)
10332 << HasFirstDefaultArgument;
10333 ODRDiagTemplateNote(SecondDecl->getLocation(),
10334 SecondDecl->getSourceRange(),
10335 ParamSingleDefaultArgument)
10336 << HasSecondDefaultArgument;
10337 break;
10338 }
10339
10340 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&
10341 "Expecting default arguments.");
10342
10343 ODRDiagTemplateError(FirstDecl->getLocation(),
10344 FirstDecl->getSourceRange(),
10345 ParamDifferentDefaultArgument);
10346 ODRDiagTemplateNote(SecondDecl->getLocation(),
10347 SecondDecl->getSourceRange(),
10348 ParamDifferentDefaultArgument);
10349
10350 break;
10351 }
10352 }
10353
10354 break;
10355 }
10356
10357 if (FirstIt != FirstEnd) {
10358 Diagnosed = true;
10359 break;
10360 }
10361 }
10362
10363 DeclHashes FirstHashes;
10364 DeclHashes SecondHashes;
10365 const DeclContext *DC = FirstRecord;
10366 PopulateHashes(FirstHashes, FirstRecord, DC);
10367 PopulateHashes(SecondHashes, SecondRecord, DC);
10368
10369 auto DR = FindTypeDiffs(FirstHashes, SecondHashes);
10370 ODRMismatchDecl FirstDiffType = DR.FirstDiffType;
10371 ODRMismatchDecl SecondDiffType = DR.SecondDiffType;
10372 Decl *FirstDecl = DR.FirstDecl;
10373 Decl *SecondDecl = DR.SecondDecl;
10374
10375 if (FirstDiffType == Other || SecondDiffType == Other) {
10376 DiagnoseODRUnexpected(DR, FirstRecord, FirstModule, SecondRecord,
10377 SecondModule);
10378 Diagnosed = true;
10379 break;
10380 }
10381
10382 if (FirstDiffType != SecondDiffType) {
10383 DiagnoseODRMismatch(DR, FirstRecord, FirstModule, SecondRecord,
10384 SecondModule);
10385 Diagnosed = true;
10386 break;
10387 }
10388
10389 assert(FirstDiffType == SecondDiffType);
10390
10391 switch (FirstDiffType) {
10392 case Other:
10393 case EndOfClass:
10394 case PublicSpecifer:
10395 case PrivateSpecifer:
10396 case ProtectedSpecifer:
10397 llvm_unreachable("Invalid diff type");
10398
10399 case StaticAssert: {
10400 StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10401 StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10402
10403 Expr *FirstExpr = FirstSA->getAssertExpr();
10404 Expr *SecondExpr = SecondSA->getAssertExpr();
10405 unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10406 unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10407 if (FirstODRHash != SecondODRHash) {
10408 ODRDiagDeclError(FirstRecord, FirstModule, FirstExpr->getBeginLoc(),
10409 FirstExpr->getSourceRange(), StaticAssertCondition);
10410 ODRDiagDeclNote(SecondModule, SecondExpr->getBeginLoc(),
10411 SecondExpr->getSourceRange(), StaticAssertCondition);
10412 Diagnosed = true;
10413 break;
10414 }
10415
10416 StringLiteral *FirstStr = FirstSA->getMessage();
10417 StringLiteral *SecondStr = SecondSA->getMessage();
10418 assert((FirstStr || SecondStr) && "Both messages cannot be empty");
10419 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10420 SourceLocation FirstLoc, SecondLoc;
10421 SourceRange FirstRange, SecondRange;
10422 if (FirstStr) {
10423 FirstLoc = FirstStr->getBeginLoc();
10424 FirstRange = FirstStr->getSourceRange();
10425 } else {
10426 FirstLoc = FirstSA->getBeginLoc();
10427 FirstRange = FirstSA->getSourceRange();
10428 }
10429 if (SecondStr) {
10430 SecondLoc = SecondStr->getBeginLoc();
10431 SecondRange = SecondStr->getSourceRange();
10432 } else {
10433 SecondLoc = SecondSA->getBeginLoc();
10434 SecondRange = SecondSA->getSourceRange();
10435 }
10436 ODRDiagDeclError(FirstRecord, FirstModule, FirstLoc, FirstRange,
10437 StaticAssertOnlyMessage)
10438 << (FirstStr == nullptr);
10439 ODRDiagDeclNote(SecondModule, SecondLoc, SecondRange,
10440 StaticAssertOnlyMessage)
10441 << (SecondStr == nullptr);
10442 Diagnosed = true;
10443 break;
10444 }
10445
10446 if (FirstStr && SecondStr &&
10447 FirstStr->getString() != SecondStr->getString()) {
10448 ODRDiagDeclError(FirstRecord, FirstModule, FirstStr->getBeginLoc(),
10449 FirstStr->getSourceRange(), StaticAssertMessage);
10450 ODRDiagDeclNote(SecondModule, SecondStr->getBeginLoc(),
10451 SecondStr->getSourceRange(), StaticAssertMessage);
10452 Diagnosed = true;
10453 break;
10454 }
10455 break;
10456 }
10457 case Field: {
10458 Diagnosed = ODRDiagField(FirstRecord, FirstModule, SecondModule,
10459 cast<FieldDecl>(FirstDecl),
10460 cast<FieldDecl>(SecondDecl));
10461 break;
10462 }
10463 case CXXMethod: {
10464 enum {
10465 DiagMethod,
10466 DiagConstructor,
10467 DiagDestructor,
10468 } FirstMethodType,
10469 SecondMethodType;
10470 auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10471 if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10472 if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10473 return DiagMethod;
10474 };
10475 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10476 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10477 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10478 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10479 auto FirstName = FirstMethod->getDeclName();
10480 auto SecondName = SecondMethod->getDeclName();
10481 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10482 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10483 FirstMethod->getSourceRange(), MethodName)
10484 << FirstMethodType << FirstName;
10485 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10486 SecondMethod->getSourceRange(), MethodName)
10487 << SecondMethodType << SecondName;
10488
10489 Diagnosed = true;
10490 break;
10491 }
10492
10493 const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10494 const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10495 if (FirstDeleted != SecondDeleted) {
10496 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10497 FirstMethod->getSourceRange(), MethodDeleted)
10498 << FirstMethodType << FirstName << FirstDeleted;
10499
10500 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10501 SecondMethod->getSourceRange(), MethodDeleted)
10502 << SecondMethodType << SecondName << SecondDeleted;
10503 Diagnosed = true;
10504 break;
10505 }
10506
10507 const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10508 const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10509 if (FirstDefaulted != SecondDefaulted) {
10510 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10511 FirstMethod->getSourceRange(), MethodDefaulted)
10512 << FirstMethodType << FirstName << FirstDefaulted;
10513
10514 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10515 SecondMethod->getSourceRange(), MethodDefaulted)
10516 << SecondMethodType << SecondName << SecondDefaulted;
10517 Diagnosed = true;
10518 break;
10519 }
10520
10521 const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10522 const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10523 const bool FirstPure = FirstMethod->isPure();
10524 const bool SecondPure = SecondMethod->isPure();
10525 if ((FirstVirtual || SecondVirtual) &&
10526 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10527 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10528 FirstMethod->getSourceRange(), MethodVirtual)
10529 << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10530 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10531 SecondMethod->getSourceRange(), MethodVirtual)
10532 << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10533 Diagnosed = true;
10534 break;
10535 }
10536
10537 // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10538 // FirstDecl is the canonical Decl of SecondDecl, so the storage
10539 // class needs to be checked instead.
10540 const auto FirstStorage = FirstMethod->getStorageClass();
10541 const auto SecondStorage = SecondMethod->getStorageClass();
10542 const bool FirstStatic = FirstStorage == SC_Static;
10543 const bool SecondStatic = SecondStorage == SC_Static;
10544 if (FirstStatic != SecondStatic) {
10545 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10546 FirstMethod->getSourceRange(), MethodStatic)
10547 << FirstMethodType << FirstName << FirstStatic;
10548 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10549 SecondMethod->getSourceRange(), MethodStatic)
10550 << SecondMethodType << SecondName << SecondStatic;
10551 Diagnosed = true;
10552 break;
10553 }
10554
10555 const bool FirstVolatile = FirstMethod->isVolatile();
10556 const bool SecondVolatile = SecondMethod->isVolatile();
10557 if (FirstVolatile != SecondVolatile) {
10558 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10559 FirstMethod->getSourceRange(), MethodVolatile)
10560 << FirstMethodType << FirstName << FirstVolatile;
10561 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10562 SecondMethod->getSourceRange(), MethodVolatile)
10563 << SecondMethodType << SecondName << SecondVolatile;
10564 Diagnosed = true;
10565 break;
10566 }
10567
10568 const bool FirstConst = FirstMethod->isConst();
10569 const bool SecondConst = SecondMethod->isConst();
10570 if (FirstConst != SecondConst) {
10571 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10572 FirstMethod->getSourceRange(), MethodConst)
10573 << FirstMethodType << FirstName << FirstConst;
10574 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10575 SecondMethod->getSourceRange(), MethodConst)
10576 << SecondMethodType << SecondName << SecondConst;
10577 Diagnosed = true;
10578 break;
10579 }
10580
10581 const bool FirstInline = FirstMethod->isInlineSpecified();
10582 const bool SecondInline = SecondMethod->isInlineSpecified();
10583 if (FirstInline != SecondInline) {
10584 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10585 FirstMethod->getSourceRange(), MethodInline)
10586 << FirstMethodType << FirstName << FirstInline;
10587 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10588 SecondMethod->getSourceRange(), MethodInline)
10589 << SecondMethodType << SecondName << SecondInline;
10590 Diagnosed = true;
10591 break;
10592 }
10593
10594 const unsigned FirstNumParameters = FirstMethod->param_size();
10595 const unsigned SecondNumParameters = SecondMethod->param_size();
10596 if (FirstNumParameters != SecondNumParameters) {
10597 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10598 FirstMethod->getSourceRange(),
10599 MethodNumberParameters)
10600 << FirstMethodType << FirstName << FirstNumParameters;
10601 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10602 SecondMethod->getSourceRange(),
10603 MethodNumberParameters)
10604 << SecondMethodType << SecondName << SecondNumParameters;
10605 Diagnosed = true;
10606 break;
10607 }
10608
10609 // Need this status boolean to know when break out of the switch.
10610 bool ParameterMismatch = false;
10611 for (unsigned I = 0; I < FirstNumParameters; ++I) {
10612 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10613 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10614
10615 QualType FirstParamType = FirstParam->getType();
10616 QualType SecondParamType = SecondParam->getType();
10617 if (FirstParamType != SecondParamType &&
10618 ComputeQualTypeODRHash(FirstParamType) !=
10619 ComputeQualTypeODRHash(SecondParamType)) {
10620 if (const DecayedType *ParamDecayedType =
10621 FirstParamType->getAs<DecayedType>()) {
10622 ODRDiagDeclError(
10623 FirstRecord, FirstModule, FirstMethod->getLocation(),
10624 FirstMethod->getSourceRange(), MethodParameterType)
10625 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10626 << true << ParamDecayedType->getOriginalType();
10627 } else {
10628 ODRDiagDeclError(
10629 FirstRecord, FirstModule, FirstMethod->getLocation(),
10630 FirstMethod->getSourceRange(), MethodParameterType)
10631 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10632 << false;
10633 }
10634
10635 if (const DecayedType *ParamDecayedType =
10636 SecondParamType->getAs<DecayedType>()) {
10637 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10638 SecondMethod->getSourceRange(),
10639 MethodParameterType)
10640 << SecondMethodType << SecondName << (I + 1)
10641 << SecondParamType << true
10642 << ParamDecayedType->getOriginalType();
10643 } else {
10644 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10645 SecondMethod->getSourceRange(),
10646 MethodParameterType)
10647 << SecondMethodType << SecondName << (I + 1)
10648 << SecondParamType << false;
10649 }
10650 ParameterMismatch = true;
10651 break;
10652 }
10653
10654 DeclarationName FirstParamName = FirstParam->getDeclName();
10655 DeclarationName SecondParamName = SecondParam->getDeclName();
10656 if (FirstParamName != SecondParamName) {
10657 ODRDiagDeclError(FirstRecord, FirstModule,
10658 FirstMethod->getLocation(),
10659 FirstMethod->getSourceRange(), MethodParameterName)
10660 << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10661 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10662 SecondMethod->getSourceRange(), MethodParameterName)
10663 << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10664 ParameterMismatch = true;
10665 break;
10666 }
10667
10668 const Expr *FirstInit = FirstParam->getInit();
10669 const Expr *SecondInit = SecondParam->getInit();
10670 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10671 ODRDiagDeclError(FirstRecord, FirstModule,
10672 FirstMethod->getLocation(),
10673 FirstMethod->getSourceRange(),
10674 MethodParameterSingleDefaultArgument)
10675 << FirstMethodType << FirstName << (I + 1)
10676 << (FirstInit == nullptr)
10677 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10678 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10679 SecondMethod->getSourceRange(),
10680 MethodParameterSingleDefaultArgument)
10681 << SecondMethodType << SecondName << (I + 1)
10682 << (SecondInit == nullptr)
10683 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10684 ParameterMismatch = true;
10685 break;
10686 }
10687
10688 if (FirstInit && SecondInit &&
10689 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10690 ODRDiagDeclError(FirstRecord, FirstModule,
10691 FirstMethod->getLocation(),
10692 FirstMethod->getSourceRange(),
10693 MethodParameterDifferentDefaultArgument)
10694 << FirstMethodType << FirstName << (I + 1)
10695 << FirstInit->getSourceRange();
10696 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10697 SecondMethod->getSourceRange(),
10698 MethodParameterDifferentDefaultArgument)
10699 << SecondMethodType << SecondName << (I + 1)
10700 << SecondInit->getSourceRange();
10701 ParameterMismatch = true;
10702 break;
10703
10704 }
10705 }
10706
10707 if (ParameterMismatch) {
10708 Diagnosed = true;
10709 break;
10710 }
10711
10712 const auto *FirstTemplateArgs =
10713 FirstMethod->getTemplateSpecializationArgs();
10714 const auto *SecondTemplateArgs =
10715 SecondMethod->getTemplateSpecializationArgs();
10716
10717 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10718 (!FirstTemplateArgs && SecondTemplateArgs)) {
10719 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10720 FirstMethod->getSourceRange(),
10721 MethodNoTemplateArguments)
10722 << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10723 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10724 SecondMethod->getSourceRange(),
10725 MethodNoTemplateArguments)
10726 << SecondMethodType << SecondName
10727 << (SecondTemplateArgs != nullptr);
10728
10729 Diagnosed = true;
10730 break;
10731 }
10732
10733 if (FirstTemplateArgs && SecondTemplateArgs) {
10734 // Remove pack expansions from argument list.
10735 auto ExpandTemplateArgumentList =
10736 [](const TemplateArgumentList *TAL) {
10737 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
10738 for (const TemplateArgument &TA : TAL->asArray()) {
10739 if (TA.getKind() != TemplateArgument::Pack) {
10740 ExpandedList.push_back(&TA);
10741 continue;
10742 }
10743 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10744 ExpandedList.push_back(&PackTA);
10745 }
10746 }
10747 return ExpandedList;
10748 };
10749 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
10750 ExpandTemplateArgumentList(FirstTemplateArgs);
10751 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
10752 ExpandTemplateArgumentList(SecondTemplateArgs);
10753
10754 if (FirstExpandedList.size() != SecondExpandedList.size()) {
10755 ODRDiagDeclError(FirstRecord, FirstModule,
10756 FirstMethod->getLocation(),
10757 FirstMethod->getSourceRange(),
10758 MethodDifferentNumberTemplateArguments)
10759 << FirstMethodType << FirstName
10760 << (unsigned)FirstExpandedList.size();
10761 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10762 SecondMethod->getSourceRange(),
10763 MethodDifferentNumberTemplateArguments)
10764 << SecondMethodType << SecondName
10765 << (unsigned)SecondExpandedList.size();
10766
10767 Diagnosed = true;
10768 break;
10769 }
10770
10771 bool TemplateArgumentMismatch = false;
10772 for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10773 const TemplateArgument &FirstTA = *FirstExpandedList[i],
10774 &SecondTA = *SecondExpandedList[i];
10775 if (ComputeTemplateArgumentODRHash(FirstTA) ==
10776 ComputeTemplateArgumentODRHash(SecondTA)) {
10777 continue;
10778 }
10779
10780 ODRDiagDeclError(
10781 FirstRecord, FirstModule, FirstMethod->getLocation(),
10782 FirstMethod->getSourceRange(), MethodDifferentTemplateArgument)
10783 << FirstMethodType << FirstName << FirstTA << i + 1;
10784 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10785 SecondMethod->getSourceRange(),
10786 MethodDifferentTemplateArgument)
10787 << SecondMethodType << SecondName << SecondTA << i + 1;
10788
10789 TemplateArgumentMismatch = true;
10790 break;
10791 }
10792
10793 if (TemplateArgumentMismatch) {
10794 Diagnosed = true;
10795 break;
10796 }
10797 }
10798
10799 // Compute the hash of the method as if it has no body.
10800 auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10801 Hash.clear();
10802 Hash.AddFunctionDecl(D, true /*SkipBody*/);
10803 return Hash.CalculateHash();
10804 };
10805
10806 // Compare the hash generated to the hash stored. A difference means
10807 // that a body was present in the original source. Due to merging,
10808 // the stardard way of detecting a body will not work.
10809 const bool HasFirstBody =
10810 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10811 const bool HasSecondBody =
10812 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10813
10814 if (HasFirstBody != HasSecondBody) {
10815 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10816 FirstMethod->getSourceRange(), MethodSingleBody)
10817 << FirstMethodType << FirstName << HasFirstBody;
10818 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10819 SecondMethod->getSourceRange(), MethodSingleBody)
10820 << SecondMethodType << SecondName << HasSecondBody;
10821 Diagnosed = true;
10822 break;
10823 }
10824
10825 if (HasFirstBody && HasSecondBody) {
10826 ODRDiagDeclError(FirstRecord, FirstModule, FirstMethod->getLocation(),
10827 FirstMethod->getSourceRange(), MethodDifferentBody)
10828 << FirstMethodType << FirstName;
10829 ODRDiagDeclNote(SecondModule, SecondMethod->getLocation(),
10830 SecondMethod->getSourceRange(), MethodDifferentBody)
10831 << SecondMethodType << SecondName;
10832 Diagnosed = true;
10833 break;
10834 }
10835
10836 break;
10837 }
10838 case TypeAlias:
10839 case TypeDef: {
10840 Diagnosed = ODRDiagTypeDefOrAlias(
10841 FirstRecord, FirstModule, SecondModule,
10842 cast<TypedefNameDecl>(FirstDecl), cast<TypedefNameDecl>(SecondDecl),
10843 FirstDiffType == TypeAlias);
10844 break;
10845 }
10846 case Var: {
10847 Diagnosed =
10848 ODRDiagVar(FirstRecord, FirstModule, SecondModule,
10849 cast<VarDecl>(FirstDecl), cast<VarDecl>(SecondDecl));
10850 break;
10851 }
10852 case Friend: {
10853 FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10854 FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10855
10856 NamedDecl *FirstND = FirstFriend->getFriendDecl();
10857 NamedDecl *SecondND = SecondFriend->getFriendDecl();
10858
10859 TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10860 TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10861
10862 if (FirstND && SecondND) {
10863 ODRDiagDeclError(FirstRecord, FirstModule,
10864 FirstFriend->getFriendLoc(),
10865 FirstFriend->getSourceRange(), FriendFunction)
10866 << FirstND;
10867 ODRDiagDeclNote(SecondModule, SecondFriend->getFriendLoc(),
10868 SecondFriend->getSourceRange(), FriendFunction)
10869 << SecondND;
10870
10871 Diagnosed = true;
10872 break;
10873 }
10874
10875 if (FirstTSI && SecondTSI) {
10876 QualType FirstFriendType = FirstTSI->getType();
10877 QualType SecondFriendType = SecondTSI->getType();
10878 assert(ComputeQualTypeODRHash(FirstFriendType) !=
10879 ComputeQualTypeODRHash(SecondFriendType));
10880 ODRDiagDeclError(FirstRecord, FirstModule,
10881 FirstFriend->getFriendLoc(),
10882 FirstFriend->getSourceRange(), FriendType)
10883 << FirstFriendType;
10884 ODRDiagDeclNote(SecondModule, SecondFriend->getFriendLoc(),
10885 SecondFriend->getSourceRange(), FriendType)
10886 << SecondFriendType;
10887 Diagnosed = true;
10888 break;
10889 }
10890
10891 ODRDiagDeclError(FirstRecord, FirstModule, FirstFriend->getFriendLoc(),
10892 FirstFriend->getSourceRange(), FriendTypeFunction)
10893 << (FirstTSI == nullptr);
10894 ODRDiagDeclNote(SecondModule, SecondFriend->getFriendLoc(),
10895 SecondFriend->getSourceRange(), FriendTypeFunction)
10896 << (SecondTSI == nullptr);
10897
10898 Diagnosed = true;
10899 break;
10900 }
10901 case FunctionTemplate: {
10902 FunctionTemplateDecl *FirstTemplate =
10903 cast<FunctionTemplateDecl>(FirstDecl);
10904 FunctionTemplateDecl *SecondTemplate =
10905 cast<FunctionTemplateDecl>(SecondDecl);
10906
10907 TemplateParameterList *FirstTPL =
10908 FirstTemplate->getTemplateParameters();
10909 TemplateParameterList *SecondTPL =
10910 SecondTemplate->getTemplateParameters();
10911
10912 if (FirstTPL->size() != SecondTPL->size()) {
10913 ODRDiagDeclError(FirstRecord, FirstModule,
10914 FirstTemplate->getLocation(),
10915 FirstTemplate->getSourceRange(),
10916 FunctionTemplateDifferentNumberParameters)
10917 << FirstTemplate << FirstTPL->size();
10918 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10919 SecondTemplate->getSourceRange(),
10920 FunctionTemplateDifferentNumberParameters)
10921 << SecondTemplate << SecondTPL->size();
10922
10923 Diagnosed = true;
10924 break;
10925 }
10926
10927 bool ParameterMismatch = false;
10928 for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10929 NamedDecl *FirstParam = FirstTPL->getParam(i);
10930 NamedDecl *SecondParam = SecondTPL->getParam(i);
10931
10932 if (FirstParam->getKind() != SecondParam->getKind()) {
10933 enum {
10934 TemplateTypeParameter,
10935 NonTypeTemplateParameter,
10936 TemplateTemplateParameter,
10937 };
10938 auto GetParamType = [](NamedDecl *D) {
10939 switch (D->getKind()) {
10940 default:
10941 llvm_unreachable("Unexpected template parameter type");
10942 case Decl::TemplateTypeParm:
10943 return TemplateTypeParameter;
10944 case Decl::NonTypeTemplateParm:
10945 return NonTypeTemplateParameter;
10946 case Decl::TemplateTemplateParm:
10947 return TemplateTemplateParameter;
10948 }
10949 };
10950
10951 ODRDiagDeclError(FirstRecord, FirstModule,
10952 FirstTemplate->getLocation(),
10953 FirstTemplate->getSourceRange(),
10954 FunctionTemplateParameterDifferentKind)
10955 << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10956 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10957 SecondTemplate->getSourceRange(),
10958 FunctionTemplateParameterDifferentKind)
10959 << SecondTemplate << (i + 1) << GetParamType(SecondParam);
10960
10961 ParameterMismatch = true;
10962 break;
10963 }
10964
10965 if (FirstParam->getName() != SecondParam->getName()) {
10966 ODRDiagDeclError(
10967 FirstRecord, FirstModule, FirstTemplate->getLocation(),
10968 FirstTemplate->getSourceRange(), FunctionTemplateParameterName)
10969 << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
10970 << FirstParam;
10971 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10972 SecondTemplate->getSourceRange(),
10973 FunctionTemplateParameterName)
10974 << SecondTemplate << (i + 1)
10975 << (bool)SecondParam->getIdentifier() << SecondParam;
10976 ParameterMismatch = true;
10977 break;
10978 }
10979
10980 if (isa<TemplateTypeParmDecl>(FirstParam) &&
10981 isa<TemplateTypeParmDecl>(SecondParam)) {
10982 TemplateTypeParmDecl *FirstTTPD =
10983 cast<TemplateTypeParmDecl>(FirstParam);
10984 TemplateTypeParmDecl *SecondTTPD =
10985 cast<TemplateTypeParmDecl>(SecondParam);
10986 bool HasFirstDefaultArgument =
10987 FirstTTPD->hasDefaultArgument() &&
10988 !FirstTTPD->defaultArgumentWasInherited();
10989 bool HasSecondDefaultArgument =
10990 SecondTTPD->hasDefaultArgument() &&
10991 !SecondTTPD->defaultArgumentWasInherited();
10992 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10993 ODRDiagDeclError(FirstRecord, FirstModule,
10994 FirstTemplate->getLocation(),
10995 FirstTemplate->getSourceRange(),
10996 FunctionTemplateParameterSingleDefaultArgument)
10997 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
10998 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
10999 SecondTemplate->getSourceRange(),
11000 FunctionTemplateParameterSingleDefaultArgument)
11001 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11002 ParameterMismatch = true;
11003 break;
11004 }
11005
11006 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11007 QualType FirstType = FirstTTPD->getDefaultArgument();
11008 QualType SecondType = SecondTTPD->getDefaultArgument();
11009 if (ComputeQualTypeODRHash(FirstType) !=
11010 ComputeQualTypeODRHash(SecondType)) {
11011 ODRDiagDeclError(
11012 FirstRecord, FirstModule, FirstTemplate->getLocation(),
11013 FirstTemplate->getSourceRange(),
11014 FunctionTemplateParameterDifferentDefaultArgument)
11015 << FirstTemplate << (i + 1) << FirstType;
11016 ODRDiagDeclNote(
11017 SecondModule, SecondTemplate->getLocation(),
11018 SecondTemplate->getSourceRange(),
11019 FunctionTemplateParameterDifferentDefaultArgument)
11020 << SecondTemplate << (i + 1) << SecondType;
11021 ParameterMismatch = true;
11022 break;
11023 }
11024 }
11025
11026 if (FirstTTPD->isParameterPack() !=
11027 SecondTTPD->isParameterPack()) {
11028 ODRDiagDeclError(FirstRecord, FirstModule,
11029 FirstTemplate->getLocation(),
11030 FirstTemplate->getSourceRange(),
11031 FunctionTemplatePackParameter)
11032 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11033 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11034 SecondTemplate->getSourceRange(),
11035 FunctionTemplatePackParameter)
11036 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11037 ParameterMismatch = true;
11038 break;
11039 }
11040 }
11041
11042 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
11043 isa<TemplateTemplateParmDecl>(SecondParam)) {
11044 TemplateTemplateParmDecl *FirstTTPD =
11045 cast<TemplateTemplateParmDecl>(FirstParam);
11046 TemplateTemplateParmDecl *SecondTTPD =
11047 cast<TemplateTemplateParmDecl>(SecondParam);
11048
11049 TemplateParameterList *FirstTPL =
11050 FirstTTPD->getTemplateParameters();
11051 TemplateParameterList *SecondTPL =
11052 SecondTTPD->getTemplateParameters();
11053
11054 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
11055 ComputeTemplateParameterListODRHash(SecondTPL)) {
11056 ODRDiagDeclError(FirstRecord, FirstModule,
11057 FirstTemplate->getLocation(),
11058 FirstTemplate->getSourceRange(),
11059 FunctionTemplateParameterDifferentType)
11060 << FirstTemplate << (i + 1);
11061 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11062 SecondTemplate->getSourceRange(),
11063 FunctionTemplateParameterDifferentType)
11064 << SecondTemplate << (i + 1);
11065 ParameterMismatch = true;
11066 break;
11067 }
11068
11069 bool HasFirstDefaultArgument =
11070 FirstTTPD->hasDefaultArgument() &&
11071 !FirstTTPD->defaultArgumentWasInherited();
11072 bool HasSecondDefaultArgument =
11073 SecondTTPD->hasDefaultArgument() &&
11074 !SecondTTPD->defaultArgumentWasInherited();
11075 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11076 ODRDiagDeclError(FirstRecord, FirstModule,
11077 FirstTemplate->getLocation(),
11078 FirstTemplate->getSourceRange(),
11079 FunctionTemplateParameterSingleDefaultArgument)
11080 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11081 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11082 SecondTemplate->getSourceRange(),
11083 FunctionTemplateParameterSingleDefaultArgument)
11084 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11085 ParameterMismatch = true;
11086 break;
11087 }
11088
11089 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11090 TemplateArgument FirstTA =
11091 FirstTTPD->getDefaultArgument().getArgument();
11092 TemplateArgument SecondTA =
11093 SecondTTPD->getDefaultArgument().getArgument();
11094 if (ComputeTemplateArgumentODRHash(FirstTA) !=
11095 ComputeTemplateArgumentODRHash(SecondTA)) {
11096 ODRDiagDeclError(
11097 FirstRecord, FirstModule, FirstTemplate->getLocation(),
11098 FirstTemplate->getSourceRange(),
11099 FunctionTemplateParameterDifferentDefaultArgument)
11100 << FirstTemplate << (i + 1) << FirstTA;
11101 ODRDiagDeclNote(
11102 SecondModule, SecondTemplate->getLocation(),
11103 SecondTemplate->getSourceRange(),
11104 FunctionTemplateParameterDifferentDefaultArgument)
11105 << SecondTemplate << (i + 1) << SecondTA;
11106 ParameterMismatch = true;
11107 break;
11108 }
11109 }
11110
11111 if (FirstTTPD->isParameterPack() !=
11112 SecondTTPD->isParameterPack()) {
11113 ODRDiagDeclError(FirstRecord, FirstModule,
11114 FirstTemplate->getLocation(),
11115 FirstTemplate->getSourceRange(),
11116 FunctionTemplatePackParameter)
11117 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11118 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11119 SecondTemplate->getSourceRange(),
11120 FunctionTemplatePackParameter)
11121 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11122 ParameterMismatch = true;
11123 break;
11124 }
11125 }
11126
11127 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11128 isa<NonTypeTemplateParmDecl>(SecondParam)) {
11129 NonTypeTemplateParmDecl *FirstNTTPD =
11130 cast<NonTypeTemplateParmDecl>(FirstParam);
11131 NonTypeTemplateParmDecl *SecondNTTPD =
11132 cast<NonTypeTemplateParmDecl>(SecondParam);
11133
11134 QualType FirstType = FirstNTTPD->getType();
11135 QualType SecondType = SecondNTTPD->getType();
11136 if (ComputeQualTypeODRHash(FirstType) !=
11137 ComputeQualTypeODRHash(SecondType)) {
11138 ODRDiagDeclError(FirstRecord, FirstModule,
11139 FirstTemplate->getLocation(),
11140 FirstTemplate->getSourceRange(),
11141 FunctionTemplateParameterDifferentType)
11142 << FirstTemplate << (i + 1);
11143 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11144 SecondTemplate->getSourceRange(),
11145 FunctionTemplateParameterDifferentType)
11146 << SecondTemplate << (i + 1);
11147 ParameterMismatch = true;
11148 break;
11149 }
11150
11151 bool HasFirstDefaultArgument =
11152 FirstNTTPD->hasDefaultArgument() &&
11153 !FirstNTTPD->defaultArgumentWasInherited();
11154 bool HasSecondDefaultArgument =
11155 SecondNTTPD->hasDefaultArgument() &&
11156 !SecondNTTPD->defaultArgumentWasInherited();
11157 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11158 ODRDiagDeclError(FirstRecord, FirstModule,
11159 FirstTemplate->getLocation(),
11160 FirstTemplate->getSourceRange(),
11161 FunctionTemplateParameterSingleDefaultArgument)
11162 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11163 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11164 SecondTemplate->getSourceRange(),
11165 FunctionTemplateParameterSingleDefaultArgument)
11166 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11167 ParameterMismatch = true;
11168 break;
11169 }
11170
11171 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11172 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11173 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11174 if (ComputeODRHash(FirstDefaultArgument) !=
11175 ComputeODRHash(SecondDefaultArgument)) {
11176 ODRDiagDeclError(
11177 FirstRecord, FirstModule, FirstTemplate->getLocation(),
11178 FirstTemplate->getSourceRange(),
11179 FunctionTemplateParameterDifferentDefaultArgument)
11180 << FirstTemplate << (i + 1) << FirstDefaultArgument;
11181 ODRDiagDeclNote(
11182 SecondModule, SecondTemplate->getLocation(),
11183 SecondTemplate->getSourceRange(),
11184 FunctionTemplateParameterDifferentDefaultArgument)
11185 << SecondTemplate << (i + 1) << SecondDefaultArgument;
11186 ParameterMismatch = true;
11187 break;
11188 }
11189 }
11190
11191 if (FirstNTTPD->isParameterPack() !=
11192 SecondNTTPD->isParameterPack()) {
11193 ODRDiagDeclError(FirstRecord, FirstModule,
11194 FirstTemplate->getLocation(),
11195 FirstTemplate->getSourceRange(),
11196 FunctionTemplatePackParameter)
11197 << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11198 ODRDiagDeclNote(SecondModule, SecondTemplate->getLocation(),
11199 SecondTemplate->getSourceRange(),
11200 FunctionTemplatePackParameter)
11201 << SecondTemplate << (i + 1)
11202 << SecondNTTPD->isParameterPack();
11203 ParameterMismatch = true;
11204 break;
11205 }
11206 }
11207 }
11208
11209 if (ParameterMismatch) {
11210 Diagnosed = true;
11211 break;
11212 }
11213
11214 break;
11215 }
11216 }
11217
11218 if (Diagnosed)
11219 continue;
11220
11221 Diag(FirstDecl->getLocation(),
11222 diag::err_module_odr_violation_mismatch_decl_unknown)
11223 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11224 << FirstDecl->getSourceRange();
11225 Diag(SecondDecl->getLocation(),
11226 diag::note_module_odr_violation_mismatch_decl_unknown)
11227 << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11228 Diagnosed = true;
11229 }
11230
11231 if (!Diagnosed) {
11232 // All definitions are updates to the same declaration. This happens if a
11233 // module instantiates the declaration of a class template specialization
11234 // and two or more other modules instantiate its definition.
11235 //
11236 // FIXME: Indicate which modules had instantiations of this definition.
11237 // FIXME: How can this even happen?
11238 Diag(Merge.first->getLocation(),
11239 diag::err_module_odr_violation_different_instantiations)
11240 << Merge.first;
11241 }
11242 }
11243
11244 // Issue ODR failures diagnostics for functions.
11245 for (auto &Merge : FunctionOdrMergeFailures) {
11246 enum ODRFunctionDifference {
11247 ReturnType,
11248 ParameterName,
11249 ParameterType,
11250 ParameterSingleDefaultArgument,
11251 ParameterDifferentDefaultArgument,
11252 FunctionBody,
11253 };
11254
11255 FunctionDecl *FirstFunction = Merge.first;
11256 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11257
11258 bool Diagnosed = false;
11259 for (auto &SecondFunction : Merge.second) {
11260
11261 if (FirstFunction == SecondFunction)
11262 continue;
11263
11264 std::string SecondModule =
11265 getOwningModuleNameForDiagnostic(SecondFunction);
11266
11267 auto ODRDiagError = [FirstFunction, &FirstModule,
11268 this](SourceLocation Loc, SourceRange Range,
11269 ODRFunctionDifference DiffType) {
11270 return Diag(Loc, diag::err_module_odr_violation_function)
11271 << FirstFunction << FirstModule.empty() << FirstModule << Range
11272 << DiffType;
11273 };
11274 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11275 SourceRange Range,
11276 ODRFunctionDifference DiffType) {
11277 return Diag(Loc, diag::note_module_odr_violation_function)
11278 << SecondModule << Range << DiffType;
11279 };
11280
11281 if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11282 ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11283 ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11284 FirstFunction->getReturnTypeSourceRange(), ReturnType)
11285 << FirstFunction->getReturnType();
11286 ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11287 SecondFunction->getReturnTypeSourceRange(), ReturnType)
11288 << SecondFunction->getReturnType();
11289 Diagnosed = true;
11290 break;
11291 }
11292
11293 assert(FirstFunction->param_size() == SecondFunction->param_size() &&
11294 "Merged functions with different number of parameters");
11295
11296 auto ParamSize = FirstFunction->param_size();
11297 bool ParameterMismatch = false;
11298 for (unsigned I = 0; I < ParamSize; ++I) {
11299 auto *FirstParam = FirstFunction->getParamDecl(I);
11300 auto *SecondParam = SecondFunction->getParamDecl(I);
11301
11302 assert(getContext().hasSameType(FirstParam->getType(),
11303 SecondParam->getType()) &&
11304 "Merged function has different parameter types.");
11305
11306 if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11307 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11308 ParameterName)
11309 << I + 1 << FirstParam->getDeclName();
11310 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11311 ParameterName)
11312 << I + 1 << SecondParam->getDeclName();
11313 ParameterMismatch = true;
11314 break;
11315 };
11316
11317 QualType FirstParamType = FirstParam->getType();
11318 QualType SecondParamType = SecondParam->getType();
11319 if (FirstParamType != SecondParamType &&
11320 ComputeQualTypeODRHash(FirstParamType) !=
11321 ComputeQualTypeODRHash(SecondParamType)) {
11322 if (const DecayedType *ParamDecayedType =
11323 FirstParamType->getAs<DecayedType>()) {
11324 ODRDiagError(FirstParam->getLocation(),
11325 FirstParam->getSourceRange(), ParameterType)
11326 << (I + 1) << FirstParamType << true
11327 << ParamDecayedType->getOriginalType();
11328 } else {
11329 ODRDiagError(FirstParam->getLocation(),
11330 FirstParam->getSourceRange(), ParameterType)
11331 << (I + 1) << FirstParamType << false;
11332 }
11333
11334 if (const DecayedType *ParamDecayedType =
11335 SecondParamType->getAs<DecayedType>()) {
11336 ODRDiagNote(SecondParam->getLocation(),
11337 SecondParam->getSourceRange(), ParameterType)
11338 << (I + 1) << SecondParamType << true
11339 << ParamDecayedType->getOriginalType();
11340 } else {
11341 ODRDiagNote(SecondParam->getLocation(),
11342 SecondParam->getSourceRange(), ParameterType)
11343 << (I + 1) << SecondParamType << false;
11344 }
11345 ParameterMismatch = true;
11346 break;
11347 }
11348
11349 const Expr *FirstInit = FirstParam->getInit();
11350 const Expr *SecondInit = SecondParam->getInit();
11351 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11352 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11353 ParameterSingleDefaultArgument)
11354 << (I + 1) << (FirstInit == nullptr)
11355 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11356 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11357 ParameterSingleDefaultArgument)
11358 << (I + 1) << (SecondInit == nullptr)
11359 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11360 ParameterMismatch = true;
11361 break;
11362 }
11363
11364 if (FirstInit && SecondInit &&
11365 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11366 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11367 ParameterDifferentDefaultArgument)
11368 << (I + 1) << FirstInit->getSourceRange();
11369 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11370 ParameterDifferentDefaultArgument)
11371 << (I + 1) << SecondInit->getSourceRange();
11372 ParameterMismatch = true;
11373 break;
11374 }
11375
11376 assert(ComputeSubDeclODRHash(FirstParam) ==
11377 ComputeSubDeclODRHash(SecondParam) &&
11378 "Undiagnosed parameter difference.");
11379 }
11380
11381 if (ParameterMismatch) {
11382 Diagnosed = true;
11383 break;
11384 }
11385
11386 // If no error has been generated before now, assume the problem is in
11387 // the body and generate a message.
11388 ODRDiagError(FirstFunction->getLocation(),
11389 FirstFunction->getSourceRange(), FunctionBody);
11390 ODRDiagNote(SecondFunction->getLocation(),
11391 SecondFunction->getSourceRange(), FunctionBody);
11392 Diagnosed = true;
11393 break;
11394 }
11395 (void)Diagnosed;
11396 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11397 }
11398
11399 // Issue ODR failures diagnostics for enums.
11400 for (auto &Merge : EnumOdrMergeFailures) {
11401 enum ODREnumDifference {
11402 SingleScopedEnum,
11403 EnumTagKeywordMismatch,
11404 SingleSpecifiedType,
11405 DifferentSpecifiedTypes,
11406 DifferentNumberEnumConstants,
11407 EnumConstantName,
11408 EnumConstantSingleInitilizer,
11409 EnumConstantDifferentInitilizer,
11410 };
11411
11412 // If we've already pointed out a specific problem with this enum, don't
11413 // bother issuing a general "something's different" diagnostic.
11414 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11415 continue;
11416
11417 EnumDecl *FirstEnum = Merge.first;
11418 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11419
11420 using DeclHashes =
11421 llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
11422 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11423 DeclHashes &Hashes, EnumDecl *Enum) {
11424 for (auto *D : Enum->decls()) {
11425 // Due to decl merging, the first EnumDecl is the parent of
11426 // Decls in both records.
11427 if (!ODRHash::isDeclToBeProcessed(D, FirstEnum))
11428 continue;
11429 assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind");
11430 Hashes.emplace_back(cast<EnumConstantDecl>(D),
11431 ComputeSubDeclODRHash(D));
11432 }
11433 };
11434 DeclHashes FirstHashes;
11435 PopulateHashes(FirstHashes, FirstEnum);
11436 bool Diagnosed = false;
11437 for (auto &SecondEnum : Merge.second) {
11438
11439 if (FirstEnum == SecondEnum)
11440 continue;
11441
11442 std::string SecondModule =
11443 getOwningModuleNameForDiagnostic(SecondEnum);
11444
11445 auto ODRDiagError = [FirstEnum, &FirstModule,
11446 this](SourceLocation Loc, SourceRange Range,
11447 ODREnumDifference DiffType) {
11448 return Diag(Loc, diag::err_module_odr_violation_enum)
11449 << FirstEnum << FirstModule.empty() << FirstModule << Range
11450 << DiffType;
11451 };
11452 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11453 SourceRange Range,
11454 ODREnumDifference DiffType) {
11455 return Diag(Loc, diag::note_module_odr_violation_enum)
11456 << SecondModule << Range << DiffType;
11457 };
11458
11459 if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11460 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11461 SingleScopedEnum)
11462 << FirstEnum->isScoped();
11463 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11464 SingleScopedEnum)
11465 << SecondEnum->isScoped();
11466 Diagnosed = true;
11467 continue;
11468 }
11469
11470 if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11471 if (FirstEnum->isScopedUsingClassTag() !=
11472 SecondEnum->isScopedUsingClassTag()) {
11473 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11474 EnumTagKeywordMismatch)
11475 << FirstEnum->isScopedUsingClassTag();
11476 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11477 EnumTagKeywordMismatch)
11478 << SecondEnum->isScopedUsingClassTag();
11479 Diagnosed = true;
11480 continue;
11481 }
11482 }
11483
11484 QualType FirstUnderlyingType =
11485 FirstEnum->getIntegerTypeSourceInfo()
11486 ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11487 : QualType();
11488 QualType SecondUnderlyingType =
11489 SecondEnum->getIntegerTypeSourceInfo()
11490 ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11491 : QualType();
11492 if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11493 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11494 SingleSpecifiedType)
11495 << !FirstUnderlyingType.isNull();
11496 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11497 SingleSpecifiedType)
11498 << !SecondUnderlyingType.isNull();
11499 Diagnosed = true;
11500 continue;
11501 }
11502
11503 if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11504 if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11505 ComputeQualTypeODRHash(SecondUnderlyingType)) {
11506 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11507 DifferentSpecifiedTypes)
11508 << FirstUnderlyingType;
11509 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11510 DifferentSpecifiedTypes)
11511 << SecondUnderlyingType;
11512 Diagnosed = true;
11513 continue;
11514 }
11515 }
11516
11517 DeclHashes SecondHashes;
11518 PopulateHashes(SecondHashes, SecondEnum);
11519
11520 if (FirstHashes.size() != SecondHashes.size()) {
11521 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11522 DifferentNumberEnumConstants)
11523 << (int)FirstHashes.size();
11524 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11525 DifferentNumberEnumConstants)
11526 << (int)SecondHashes.size();
11527 Diagnosed = true;
11528 continue;
11529 }
11530
11531 for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11532 if (FirstHashes[I].second == SecondHashes[I].second)
11533 continue;
11534 const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11535 const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11536
11537 if (FirstEnumConstant->getDeclName() !=
11538 SecondEnumConstant->getDeclName()) {
11539
11540 ODRDiagError(FirstEnumConstant->getLocation(),
11541 FirstEnumConstant->getSourceRange(), EnumConstantName)
11542 << I + 1 << FirstEnumConstant;
11543 ODRDiagNote(SecondEnumConstant->getLocation(),
11544 SecondEnumConstant->getSourceRange(), EnumConstantName)
11545 << I + 1 << SecondEnumConstant;
11546 Diagnosed = true;
11547 break;
11548 }
11549
11550 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11551 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11552 if (!FirstInit && !SecondInit)
11553 continue;
11554
11555 if (!FirstInit || !SecondInit) {
11556 ODRDiagError(FirstEnumConstant->getLocation(),
11557 FirstEnumConstant->getSourceRange(),
11558 EnumConstantSingleInitilizer)
11559 << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11560 ODRDiagNote(SecondEnumConstant->getLocation(),
11561 SecondEnumConstant->getSourceRange(),
11562 EnumConstantSingleInitilizer)
11563 << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11564 Diagnosed = true;
11565 break;
11566 }
11567
11568 if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11569 ODRDiagError(FirstEnumConstant->getLocation(),
11570 FirstEnumConstant->getSourceRange(),
11571 EnumConstantDifferentInitilizer)
11572 << I + 1 << FirstEnumConstant;
11573 ODRDiagNote(SecondEnumConstant->getLocation(),
11574 SecondEnumConstant->getSourceRange(),
11575 EnumConstantDifferentInitilizer)
11576 << I + 1 << SecondEnumConstant;
11577 Diagnosed = true;
11578 break;
11579 }
11580 }
11581 }
11582
11583 (void)Diagnosed;
11584 assert(Diagnosed && "Unable to emit ODR diagnostic.");
11585 }
11586 }
11587
StartedDeserializing()11588 void ASTReader::StartedDeserializing() {
11589 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11590 ReadTimer->startTimer();
11591 }
11592
FinishedDeserializing()11593 void ASTReader::FinishedDeserializing() {
11594 assert(NumCurrentElementsDeserializing &&
11595 "FinishedDeserializing not paired with StartedDeserializing");
11596 if (NumCurrentElementsDeserializing == 1) {
11597 // We decrease NumCurrentElementsDeserializing only after pending actions
11598 // are finished, to avoid recursively re-calling finishPendingActions().
11599 finishPendingActions();
11600 }
11601 --NumCurrentElementsDeserializing;
11602
11603 if (NumCurrentElementsDeserializing == 0) {
11604 // Propagate exception specification and deduced type updates along
11605 // redeclaration chains.
11606 //
11607 // We do this now rather than in finishPendingActions because we want to
11608 // be able to walk the complete redeclaration chains of the updated decls.
11609 while (!PendingExceptionSpecUpdates.empty() ||
11610 !PendingDeducedTypeUpdates.empty()) {
11611 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
11612 PendingExceptionSpecUpdates.clear();
11613 for (auto Update : ESUpdates) {
11614 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11615 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11616 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11617 if (auto *Listener = getContext().getASTMutationListener())
11618 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11619 for (auto *Redecl : Update.second->redecls())
11620 getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11621 }
11622
11623 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
11624 PendingDeducedTypeUpdates.clear();
11625 for (auto Update : DTUpdates) {
11626 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11627 // FIXME: If the return type is already deduced, check that it matches.
11628 getContext().adjustDeducedFunctionResultType(Update.first,
11629 Update.second);
11630 }
11631 }
11632
11633 if (ReadTimer)
11634 ReadTimer->stopTimer();
11635
11636 diagnoseOdrViolations();
11637
11638 // We are not in recursive loading, so it's safe to pass the "interesting"
11639 // decls to the consumer.
11640 if (Consumer)
11641 PassInterestingDeclsToConsumer();
11642 }
11643 }
11644
pushExternalDeclIntoScope(NamedDecl * D,DeclarationName Name)11645 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11646 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11647 // Remove any fake results before adding any real ones.
11648 auto It = PendingFakeLookupResults.find(II);
11649 if (It != PendingFakeLookupResults.end()) {
11650 for (auto *ND : It->second)
11651 SemaObj->IdResolver.RemoveDecl(ND);
11652 // FIXME: this works around module+PCH performance issue.
11653 // Rather than erase the result from the map, which is O(n), just clear
11654 // the vector of NamedDecls.
11655 It->second.clear();
11656 }
11657 }
11658
11659 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11660 SemaObj->TUScope->AddDecl(D);
11661 } else if (SemaObj->TUScope) {
11662 // Adding the decl to IdResolver may have failed because it was already in
11663 // (even though it was not added in scope). If it is already in, make sure
11664 // it gets in the scope as well.
11665 if (std::find(SemaObj->IdResolver.begin(Name),
11666 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11667 SemaObj->TUScope->AddDecl(D);
11668 }
11669 }
11670
ASTReader(Preprocessor & PP,InMemoryModuleCache & ModuleCache,ASTContext * Context,const PCHContainerReader & PCHContainerRdr,ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,StringRef isysroot,bool DisableValidation,bool AllowASTWithCompilerErrors,bool AllowConfigurationMismatch,bool ValidateSystemInputs,bool ValidateASTInputFilesContent,bool UseGlobalIndex,std::unique_ptr<llvm::Timer> ReadTimer)11671 ASTReader::ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
11672 ASTContext *Context,
11673 const PCHContainerReader &PCHContainerRdr,
11674 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11675 StringRef isysroot, bool DisableValidation,
11676 bool AllowASTWithCompilerErrors,
11677 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11678 bool ValidateASTInputFilesContent, bool UseGlobalIndex,
11679 std::unique_ptr<llvm::Timer> ReadTimer)
11680 : Listener(DisableValidation
11681 ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
11682 : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11683 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11684 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11685 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
11686 PCHContainerRdr, PP.getHeaderSearchInfo()),
11687 DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11688 DisableValidation(DisableValidation),
11689 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11690 AllowConfigurationMismatch(AllowConfigurationMismatch),
11691 ValidateSystemInputs(ValidateSystemInputs),
11692 ValidateASTInputFilesContent(ValidateASTInputFilesContent),
11693 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11694 SourceMgr.setExternalSLocEntrySource(this);
11695
11696 for (const auto &Ext : Extensions) {
11697 auto BlockName = Ext->getExtensionMetadata().BlockName;
11698 auto Known = ModuleFileExtensions.find(BlockName);
11699 if (Known != ModuleFileExtensions.end()) {
11700 Diags.Report(diag::warn_duplicate_module_file_extension)
11701 << BlockName;
11702 continue;
11703 }
11704
11705 ModuleFileExtensions.insert({BlockName, Ext});
11706 }
11707 }
11708
~ASTReader()11709 ASTReader::~ASTReader() {
11710 if (OwnsDeserializationListener)
11711 delete DeserializationListener;
11712 }
11713
getIdResolver()11714 IdentifierResolver &ASTReader::getIdResolver() {
11715 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11716 }
11717
readRecord(llvm::BitstreamCursor & Cursor,unsigned AbbrevID)11718 Expected<unsigned> ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11719 unsigned AbbrevID) {
11720 Idx = 0;
11721 Record.clear();
11722 return Cursor.readRecord(AbbrevID, Record);
11723 }
11724 //===----------------------------------------------------------------------===//
11725 //// OMPClauseReader implementation
11726 ////===----------------------------------------------------------------------===//
11727
11728 // This has to be in namespace clang because it's friended by all
11729 // of the OMP clauses.
11730 namespace clang {
11731
11732 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
11733 ASTRecordReader &Record;
11734 ASTContext &Context;
11735
11736 public:
OMPClauseReader(ASTRecordReader & Record)11737 OMPClauseReader(ASTRecordReader &Record)
11738 : Record(Record), Context(Record.getContext()) {}
11739
11740 #define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
11741 #include "llvm/Frontend/OpenMP/OMPKinds.def"
11742 OMPClause *readClause();
11743 void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
11744 void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
11745 };
11746
11747 } // end namespace clang
11748
readOMPClause()11749 OMPClause *ASTRecordReader::readOMPClause() {
11750 return OMPClauseReader(*this).readClause();
11751 }
11752
readClause()11753 OMPClause *OMPClauseReader::readClause() {
11754 OMPClause *C = nullptr;
11755 switch (llvm::omp::Clause(Record.readInt())) {
11756 case llvm::omp::OMPC_if:
11757 C = new (Context) OMPIfClause();
11758 break;
11759 case llvm::omp::OMPC_final:
11760 C = new (Context) OMPFinalClause();
11761 break;
11762 case llvm::omp::OMPC_num_threads:
11763 C = new (Context) OMPNumThreadsClause();
11764 break;
11765 case llvm::omp::OMPC_safelen:
11766 C = new (Context) OMPSafelenClause();
11767 break;
11768 case llvm::omp::OMPC_simdlen:
11769 C = new (Context) OMPSimdlenClause();
11770 break;
11771 case llvm::omp::OMPC_allocator:
11772 C = new (Context) OMPAllocatorClause();
11773 break;
11774 case llvm::omp::OMPC_collapse:
11775 C = new (Context) OMPCollapseClause();
11776 break;
11777 case llvm::omp::OMPC_default:
11778 C = new (Context) OMPDefaultClause();
11779 break;
11780 case llvm::omp::OMPC_proc_bind:
11781 C = new (Context) OMPProcBindClause();
11782 break;
11783 case llvm::omp::OMPC_schedule:
11784 C = new (Context) OMPScheduleClause();
11785 break;
11786 case llvm::omp::OMPC_ordered:
11787 C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
11788 break;
11789 case llvm::omp::OMPC_nowait:
11790 C = new (Context) OMPNowaitClause();
11791 break;
11792 case llvm::omp::OMPC_untied:
11793 C = new (Context) OMPUntiedClause();
11794 break;
11795 case llvm::omp::OMPC_mergeable:
11796 C = new (Context) OMPMergeableClause();
11797 break;
11798 case llvm::omp::OMPC_read:
11799 C = new (Context) OMPReadClause();
11800 break;
11801 case llvm::omp::OMPC_write:
11802 C = new (Context) OMPWriteClause();
11803 break;
11804 case llvm::omp::OMPC_update:
11805 C = OMPUpdateClause::CreateEmpty(Context, Record.readInt());
11806 break;
11807 case llvm::omp::OMPC_capture:
11808 C = new (Context) OMPCaptureClause();
11809 break;
11810 case llvm::omp::OMPC_seq_cst:
11811 C = new (Context) OMPSeqCstClause();
11812 break;
11813 case llvm::omp::OMPC_acq_rel:
11814 C = new (Context) OMPAcqRelClause();
11815 break;
11816 case llvm::omp::OMPC_acquire:
11817 C = new (Context) OMPAcquireClause();
11818 break;
11819 case llvm::omp::OMPC_release:
11820 C = new (Context) OMPReleaseClause();
11821 break;
11822 case llvm::omp::OMPC_relaxed:
11823 C = new (Context) OMPRelaxedClause();
11824 break;
11825 case llvm::omp::OMPC_threads:
11826 C = new (Context) OMPThreadsClause();
11827 break;
11828 case llvm::omp::OMPC_simd:
11829 C = new (Context) OMPSIMDClause();
11830 break;
11831 case llvm::omp::OMPC_nogroup:
11832 C = new (Context) OMPNogroupClause();
11833 break;
11834 case llvm::omp::OMPC_unified_address:
11835 C = new (Context) OMPUnifiedAddressClause();
11836 break;
11837 case llvm::omp::OMPC_unified_shared_memory:
11838 C = new (Context) OMPUnifiedSharedMemoryClause();
11839 break;
11840 case llvm::omp::OMPC_reverse_offload:
11841 C = new (Context) OMPReverseOffloadClause();
11842 break;
11843 case llvm::omp::OMPC_dynamic_allocators:
11844 C = new (Context) OMPDynamicAllocatorsClause();
11845 break;
11846 case llvm::omp::OMPC_atomic_default_mem_order:
11847 C = new (Context) OMPAtomicDefaultMemOrderClause();
11848 break;
11849 case llvm::omp::OMPC_private:
11850 C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
11851 break;
11852 case llvm::omp::OMPC_firstprivate:
11853 C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
11854 break;
11855 case llvm::omp::OMPC_lastprivate:
11856 C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
11857 break;
11858 case llvm::omp::OMPC_shared:
11859 C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
11860 break;
11861 case llvm::omp::OMPC_reduction: {
11862 unsigned N = Record.readInt();
11863 auto Modifier = Record.readEnum<OpenMPReductionClauseModifier>();
11864 C = OMPReductionClause::CreateEmpty(Context, N, Modifier);
11865 break;
11866 }
11867 case llvm::omp::OMPC_task_reduction:
11868 C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
11869 break;
11870 case llvm::omp::OMPC_in_reduction:
11871 C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
11872 break;
11873 case llvm::omp::OMPC_linear:
11874 C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
11875 break;
11876 case llvm::omp::OMPC_aligned:
11877 C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
11878 break;
11879 case llvm::omp::OMPC_copyin:
11880 C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
11881 break;
11882 case llvm::omp::OMPC_copyprivate:
11883 C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
11884 break;
11885 case llvm::omp::OMPC_flush:
11886 C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
11887 break;
11888 case llvm::omp::OMPC_depobj:
11889 C = OMPDepobjClause::CreateEmpty(Context);
11890 break;
11891 case llvm::omp::OMPC_depend: {
11892 unsigned NumVars = Record.readInt();
11893 unsigned NumLoops = Record.readInt();
11894 C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
11895 break;
11896 }
11897 case llvm::omp::OMPC_device:
11898 C = new (Context) OMPDeviceClause();
11899 break;
11900 case llvm::omp::OMPC_map: {
11901 OMPMappableExprListSizeTy Sizes;
11902 Sizes.NumVars = Record.readInt();
11903 Sizes.NumUniqueDeclarations = Record.readInt();
11904 Sizes.NumComponentLists = Record.readInt();
11905 Sizes.NumComponents = Record.readInt();
11906 C = OMPMapClause::CreateEmpty(Context, Sizes);
11907 break;
11908 }
11909 case llvm::omp::OMPC_num_teams:
11910 C = new (Context) OMPNumTeamsClause();
11911 break;
11912 case llvm::omp::OMPC_thread_limit:
11913 C = new (Context) OMPThreadLimitClause();
11914 break;
11915 case llvm::omp::OMPC_priority:
11916 C = new (Context) OMPPriorityClause();
11917 break;
11918 case llvm::omp::OMPC_grainsize:
11919 C = new (Context) OMPGrainsizeClause();
11920 break;
11921 case llvm::omp::OMPC_num_tasks:
11922 C = new (Context) OMPNumTasksClause();
11923 break;
11924 case llvm::omp::OMPC_hint:
11925 C = new (Context) OMPHintClause();
11926 break;
11927 case llvm::omp::OMPC_dist_schedule:
11928 C = new (Context) OMPDistScheduleClause();
11929 break;
11930 case llvm::omp::OMPC_defaultmap:
11931 C = new (Context) OMPDefaultmapClause();
11932 break;
11933 case llvm::omp::OMPC_to: {
11934 OMPMappableExprListSizeTy Sizes;
11935 Sizes.NumVars = Record.readInt();
11936 Sizes.NumUniqueDeclarations = Record.readInt();
11937 Sizes.NumComponentLists = Record.readInt();
11938 Sizes.NumComponents = Record.readInt();
11939 C = OMPToClause::CreateEmpty(Context, Sizes);
11940 break;
11941 }
11942 case llvm::omp::OMPC_from: {
11943 OMPMappableExprListSizeTy Sizes;
11944 Sizes.NumVars = Record.readInt();
11945 Sizes.NumUniqueDeclarations = Record.readInt();
11946 Sizes.NumComponentLists = Record.readInt();
11947 Sizes.NumComponents = Record.readInt();
11948 C = OMPFromClause::CreateEmpty(Context, Sizes);
11949 break;
11950 }
11951 case llvm::omp::OMPC_use_device_ptr: {
11952 OMPMappableExprListSizeTy Sizes;
11953 Sizes.NumVars = Record.readInt();
11954 Sizes.NumUniqueDeclarations = Record.readInt();
11955 Sizes.NumComponentLists = Record.readInt();
11956 Sizes.NumComponents = Record.readInt();
11957 C = OMPUseDevicePtrClause::CreateEmpty(Context, Sizes);
11958 break;
11959 }
11960 case llvm::omp::OMPC_use_device_addr: {
11961 OMPMappableExprListSizeTy Sizes;
11962 Sizes.NumVars = Record.readInt();
11963 Sizes.NumUniqueDeclarations = Record.readInt();
11964 Sizes.NumComponentLists = Record.readInt();
11965 Sizes.NumComponents = Record.readInt();
11966 C = OMPUseDeviceAddrClause::CreateEmpty(Context, Sizes);
11967 break;
11968 }
11969 case llvm::omp::OMPC_is_device_ptr: {
11970 OMPMappableExprListSizeTy Sizes;
11971 Sizes.NumVars = Record.readInt();
11972 Sizes.NumUniqueDeclarations = Record.readInt();
11973 Sizes.NumComponentLists = Record.readInt();
11974 Sizes.NumComponents = Record.readInt();
11975 C = OMPIsDevicePtrClause::CreateEmpty(Context, Sizes);
11976 break;
11977 }
11978 case llvm::omp::OMPC_allocate:
11979 C = OMPAllocateClause::CreateEmpty(Context, Record.readInt());
11980 break;
11981 case llvm::omp::OMPC_nontemporal:
11982 C = OMPNontemporalClause::CreateEmpty(Context, Record.readInt());
11983 break;
11984 case llvm::omp::OMPC_inclusive:
11985 C = OMPInclusiveClause::CreateEmpty(Context, Record.readInt());
11986 break;
11987 case llvm::omp::OMPC_exclusive:
11988 C = OMPExclusiveClause::CreateEmpty(Context, Record.readInt());
11989 break;
11990 case llvm::omp::OMPC_order:
11991 C = new (Context) OMPOrderClause();
11992 break;
11993 case llvm::omp::OMPC_destroy:
11994 C = new (Context) OMPDestroyClause();
11995 break;
11996 case llvm::omp::OMPC_detach:
11997 C = new (Context) OMPDetachClause();
11998 break;
11999 case llvm::omp::OMPC_uses_allocators:
12000 C = OMPUsesAllocatorsClause::CreateEmpty(Context, Record.readInt());
12001 break;
12002 case llvm::omp::OMPC_affinity:
12003 C = OMPAffinityClause::CreateEmpty(Context, Record.readInt());
12004 break;
12005 #define OMP_CLAUSE_NO_CLASS(Enum, Str) \
12006 case llvm::omp::Enum: \
12007 break;
12008 #include "llvm/Frontend/OpenMP/OMPKinds.def"
12009 default:
12010 break;
12011 }
12012 assert(C && "Unknown OMPClause type");
12013
12014 Visit(C);
12015 C->setLocStart(Record.readSourceLocation());
12016 C->setLocEnd(Record.readSourceLocation());
12017
12018 return C;
12019 }
12020
VisitOMPClauseWithPreInit(OMPClauseWithPreInit * C)12021 void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
12022 C->setPreInitStmt(Record.readSubStmt(),
12023 static_cast<OpenMPDirectiveKind>(Record.readInt()));
12024 }
12025
VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate * C)12026 void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
12027 VisitOMPClauseWithPreInit(C);
12028 C->setPostUpdateExpr(Record.readSubExpr());
12029 }
12030
VisitOMPIfClause(OMPIfClause * C)12031 void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
12032 VisitOMPClauseWithPreInit(C);
12033 C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record.readInt()));
12034 C->setNameModifierLoc(Record.readSourceLocation());
12035 C->setColonLoc(Record.readSourceLocation());
12036 C->setCondition(Record.readSubExpr());
12037 C->setLParenLoc(Record.readSourceLocation());
12038 }
12039
VisitOMPFinalClause(OMPFinalClause * C)12040 void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
12041 VisitOMPClauseWithPreInit(C);
12042 C->setCondition(Record.readSubExpr());
12043 C->setLParenLoc(Record.readSourceLocation());
12044 }
12045
VisitOMPNumThreadsClause(OMPNumThreadsClause * C)12046 void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
12047 VisitOMPClauseWithPreInit(C);
12048 C->setNumThreads(Record.readSubExpr());
12049 C->setLParenLoc(Record.readSourceLocation());
12050 }
12051
VisitOMPSafelenClause(OMPSafelenClause * C)12052 void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
12053 C->setSafelen(Record.readSubExpr());
12054 C->setLParenLoc(Record.readSourceLocation());
12055 }
12056
VisitOMPSimdlenClause(OMPSimdlenClause * C)12057 void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
12058 C->setSimdlen(Record.readSubExpr());
12059 C->setLParenLoc(Record.readSourceLocation());
12060 }
12061
VisitOMPAllocatorClause(OMPAllocatorClause * C)12062 void OMPClauseReader::VisitOMPAllocatorClause(OMPAllocatorClause *C) {
12063 C->setAllocator(Record.readExpr());
12064 C->setLParenLoc(Record.readSourceLocation());
12065 }
12066
VisitOMPCollapseClause(OMPCollapseClause * C)12067 void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
12068 C->setNumForLoops(Record.readSubExpr());
12069 C->setLParenLoc(Record.readSourceLocation());
12070 }
12071
VisitOMPDefaultClause(OMPDefaultClause * C)12072 void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
12073 C->setDefaultKind(static_cast<llvm::omp::DefaultKind>(Record.readInt()));
12074 C->setLParenLoc(Record.readSourceLocation());
12075 C->setDefaultKindKwLoc(Record.readSourceLocation());
12076 }
12077
VisitOMPProcBindClause(OMPProcBindClause * C)12078 void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
12079 C->setProcBindKind(static_cast<llvm::omp::ProcBindKind>(Record.readInt()));
12080 C->setLParenLoc(Record.readSourceLocation());
12081 C->setProcBindKindKwLoc(Record.readSourceLocation());
12082 }
12083
VisitOMPScheduleClause(OMPScheduleClause * C)12084 void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
12085 VisitOMPClauseWithPreInit(C);
12086 C->setScheduleKind(
12087 static_cast<OpenMPScheduleClauseKind>(Record.readInt()));
12088 C->setFirstScheduleModifier(
12089 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
12090 C->setSecondScheduleModifier(
12091 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
12092 C->setChunkSize(Record.readSubExpr());
12093 C->setLParenLoc(Record.readSourceLocation());
12094 C->setFirstScheduleModifierLoc(Record.readSourceLocation());
12095 C->setSecondScheduleModifierLoc(Record.readSourceLocation());
12096 C->setScheduleKindLoc(Record.readSourceLocation());
12097 C->setCommaLoc(Record.readSourceLocation());
12098 }
12099
VisitOMPOrderedClause(OMPOrderedClause * C)12100 void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
12101 C->setNumForLoops(Record.readSubExpr());
12102 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12103 C->setLoopNumIterations(I, Record.readSubExpr());
12104 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12105 C->setLoopCounter(I, Record.readSubExpr());
12106 C->setLParenLoc(Record.readSourceLocation());
12107 }
12108
VisitOMPDetachClause(OMPDetachClause * C)12109 void OMPClauseReader::VisitOMPDetachClause(OMPDetachClause *C) {
12110 C->setEventHandler(Record.readSubExpr());
12111 C->setLParenLoc(Record.readSourceLocation());
12112 }
12113
VisitOMPNowaitClause(OMPNowaitClause *)12114 void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
12115
VisitOMPUntiedClause(OMPUntiedClause *)12116 void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
12117
VisitOMPMergeableClause(OMPMergeableClause *)12118 void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
12119
VisitOMPReadClause(OMPReadClause *)12120 void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
12121
VisitOMPWriteClause(OMPWriteClause *)12122 void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
12123
VisitOMPUpdateClause(OMPUpdateClause * C)12124 void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *C) {
12125 if (C->isExtended()) {
12126 C->setLParenLoc(Record.readSourceLocation());
12127 C->setArgumentLoc(Record.readSourceLocation());
12128 C->setDependencyKind(Record.readEnum<OpenMPDependClauseKind>());
12129 }
12130 }
12131
VisitOMPCaptureClause(OMPCaptureClause *)12132 void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
12133
VisitOMPSeqCstClause(OMPSeqCstClause *)12134 void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
12135
VisitOMPAcqRelClause(OMPAcqRelClause *)12136 void OMPClauseReader::VisitOMPAcqRelClause(OMPAcqRelClause *) {}
12137
VisitOMPAcquireClause(OMPAcquireClause *)12138 void OMPClauseReader::VisitOMPAcquireClause(OMPAcquireClause *) {}
12139
VisitOMPReleaseClause(OMPReleaseClause *)12140 void OMPClauseReader::VisitOMPReleaseClause(OMPReleaseClause *) {}
12141
VisitOMPRelaxedClause(OMPRelaxedClause *)12142 void OMPClauseReader::VisitOMPRelaxedClause(OMPRelaxedClause *) {}
12143
VisitOMPThreadsClause(OMPThreadsClause *)12144 void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
12145
VisitOMPSIMDClause(OMPSIMDClause *)12146 void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
12147
VisitOMPNogroupClause(OMPNogroupClause *)12148 void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
12149
VisitOMPDestroyClause(OMPDestroyClause *)12150 void OMPClauseReader::VisitOMPDestroyClause(OMPDestroyClause *) {}
12151
VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *)12152 void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
12153
VisitOMPUnifiedSharedMemoryClause(OMPUnifiedSharedMemoryClause *)12154 void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
12155 OMPUnifiedSharedMemoryClause *) {}
12156
VisitOMPReverseOffloadClause(OMPReverseOffloadClause *)12157 void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
12158
12159 void
VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *)12160 OMPClauseReader::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) {
12161 }
12162
VisitOMPAtomicDefaultMemOrderClause(OMPAtomicDefaultMemOrderClause * C)12163 void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
12164 OMPAtomicDefaultMemOrderClause *C) {
12165 C->setAtomicDefaultMemOrderKind(
12166 static_cast<OpenMPAtomicDefaultMemOrderClauseKind>(Record.readInt()));
12167 C->setLParenLoc(Record.readSourceLocation());
12168 C->setAtomicDefaultMemOrderKindKwLoc(Record.readSourceLocation());
12169 }
12170
VisitOMPPrivateClause(OMPPrivateClause * C)12171 void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
12172 C->setLParenLoc(Record.readSourceLocation());
12173 unsigned NumVars = C->varlist_size();
12174 SmallVector<Expr *, 16> Vars;
12175 Vars.reserve(NumVars);
12176 for (unsigned i = 0; i != NumVars; ++i)
12177 Vars.push_back(Record.readSubExpr());
12178 C->setVarRefs(Vars);
12179 Vars.clear();
12180 for (unsigned i = 0; i != NumVars; ++i)
12181 Vars.push_back(Record.readSubExpr());
12182 C->setPrivateCopies(Vars);
12183 }
12184
VisitOMPFirstprivateClause(OMPFirstprivateClause * C)12185 void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
12186 VisitOMPClauseWithPreInit(C);
12187 C->setLParenLoc(Record.readSourceLocation());
12188 unsigned NumVars = C->varlist_size();
12189 SmallVector<Expr *, 16> Vars;
12190 Vars.reserve(NumVars);
12191 for (unsigned i = 0; i != NumVars; ++i)
12192 Vars.push_back(Record.readSubExpr());
12193 C->setVarRefs(Vars);
12194 Vars.clear();
12195 for (unsigned i = 0; i != NumVars; ++i)
12196 Vars.push_back(Record.readSubExpr());
12197 C->setPrivateCopies(Vars);
12198 Vars.clear();
12199 for (unsigned i = 0; i != NumVars; ++i)
12200 Vars.push_back(Record.readSubExpr());
12201 C->setInits(Vars);
12202 }
12203
VisitOMPLastprivateClause(OMPLastprivateClause * C)12204 void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
12205 VisitOMPClauseWithPostUpdate(C);
12206 C->setLParenLoc(Record.readSourceLocation());
12207 C->setKind(Record.readEnum<OpenMPLastprivateModifier>());
12208 C->setKindLoc(Record.readSourceLocation());
12209 C->setColonLoc(Record.readSourceLocation());
12210 unsigned NumVars = C->varlist_size();
12211 SmallVector<Expr *, 16> Vars;
12212 Vars.reserve(NumVars);
12213 for (unsigned i = 0; i != NumVars; ++i)
12214 Vars.push_back(Record.readSubExpr());
12215 C->setVarRefs(Vars);
12216 Vars.clear();
12217 for (unsigned i = 0; i != NumVars; ++i)
12218 Vars.push_back(Record.readSubExpr());
12219 C->setPrivateCopies(Vars);
12220 Vars.clear();
12221 for (unsigned i = 0; i != NumVars; ++i)
12222 Vars.push_back(Record.readSubExpr());
12223 C->setSourceExprs(Vars);
12224 Vars.clear();
12225 for (unsigned i = 0; i != NumVars; ++i)
12226 Vars.push_back(Record.readSubExpr());
12227 C->setDestinationExprs(Vars);
12228 Vars.clear();
12229 for (unsigned i = 0; i != NumVars; ++i)
12230 Vars.push_back(Record.readSubExpr());
12231 C->setAssignmentOps(Vars);
12232 }
12233
VisitOMPSharedClause(OMPSharedClause * C)12234 void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
12235 C->setLParenLoc(Record.readSourceLocation());
12236 unsigned NumVars = C->varlist_size();
12237 SmallVector<Expr *, 16> Vars;
12238 Vars.reserve(NumVars);
12239 for (unsigned i = 0; i != NumVars; ++i)
12240 Vars.push_back(Record.readSubExpr());
12241 C->setVarRefs(Vars);
12242 }
12243
VisitOMPReductionClause(OMPReductionClause * C)12244 void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
12245 VisitOMPClauseWithPostUpdate(C);
12246 C->setLParenLoc(Record.readSourceLocation());
12247 C->setModifierLoc(Record.readSourceLocation());
12248 C->setColonLoc(Record.readSourceLocation());
12249 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12250 DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
12251 C->setQualifierLoc(NNSL);
12252 C->setNameInfo(DNI);
12253
12254 unsigned NumVars = C->varlist_size();
12255 SmallVector<Expr *, 16> Vars;
12256 Vars.reserve(NumVars);
12257 for (unsigned i = 0; i != NumVars; ++i)
12258 Vars.push_back(Record.readSubExpr());
12259 C->setVarRefs(Vars);
12260 Vars.clear();
12261 for (unsigned i = 0; i != NumVars; ++i)
12262 Vars.push_back(Record.readSubExpr());
12263 C->setPrivates(Vars);
12264 Vars.clear();
12265 for (unsigned i = 0; i != NumVars; ++i)
12266 Vars.push_back(Record.readSubExpr());
12267 C->setLHSExprs(Vars);
12268 Vars.clear();
12269 for (unsigned i = 0; i != NumVars; ++i)
12270 Vars.push_back(Record.readSubExpr());
12271 C->setRHSExprs(Vars);
12272 Vars.clear();
12273 for (unsigned i = 0; i != NumVars; ++i)
12274 Vars.push_back(Record.readSubExpr());
12275 C->setReductionOps(Vars);
12276 if (C->getModifier() == OMPC_REDUCTION_inscan) {
12277 Vars.clear();
12278 for (unsigned i = 0; i != NumVars; ++i)
12279 Vars.push_back(Record.readSubExpr());
12280 C->setInscanCopyOps(Vars);
12281 Vars.clear();
12282 for (unsigned i = 0; i != NumVars; ++i)
12283 Vars.push_back(Record.readSubExpr());
12284 C->setInscanCopyArrayTemps(Vars);
12285 Vars.clear();
12286 for (unsigned i = 0; i != NumVars; ++i)
12287 Vars.push_back(Record.readSubExpr());
12288 C->setInscanCopyArrayElems(Vars);
12289 }
12290 }
12291
VisitOMPTaskReductionClause(OMPTaskReductionClause * C)12292 void OMPClauseReader::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) {
12293 VisitOMPClauseWithPostUpdate(C);
12294 C->setLParenLoc(Record.readSourceLocation());
12295 C->setColonLoc(Record.readSourceLocation());
12296 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12297 DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
12298 C->setQualifierLoc(NNSL);
12299 C->setNameInfo(DNI);
12300
12301 unsigned NumVars = C->varlist_size();
12302 SmallVector<Expr *, 16> Vars;
12303 Vars.reserve(NumVars);
12304 for (unsigned I = 0; I != NumVars; ++I)
12305 Vars.push_back(Record.readSubExpr());
12306 C->setVarRefs(Vars);
12307 Vars.clear();
12308 for (unsigned I = 0; I != NumVars; ++I)
12309 Vars.push_back(Record.readSubExpr());
12310 C->setPrivates(Vars);
12311 Vars.clear();
12312 for (unsigned I = 0; I != NumVars; ++I)
12313 Vars.push_back(Record.readSubExpr());
12314 C->setLHSExprs(Vars);
12315 Vars.clear();
12316 for (unsigned I = 0; I != NumVars; ++I)
12317 Vars.push_back(Record.readSubExpr());
12318 C->setRHSExprs(Vars);
12319 Vars.clear();
12320 for (unsigned I = 0; I != NumVars; ++I)
12321 Vars.push_back(Record.readSubExpr());
12322 C->setReductionOps(Vars);
12323 }
12324
VisitOMPInReductionClause(OMPInReductionClause * C)12325 void OMPClauseReader::VisitOMPInReductionClause(OMPInReductionClause *C) {
12326 VisitOMPClauseWithPostUpdate(C);
12327 C->setLParenLoc(Record.readSourceLocation());
12328 C->setColonLoc(Record.readSourceLocation());
12329 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12330 DeclarationNameInfo DNI = Record.readDeclarationNameInfo();
12331 C->setQualifierLoc(NNSL);
12332 C->setNameInfo(DNI);
12333
12334 unsigned NumVars = C->varlist_size();
12335 SmallVector<Expr *, 16> Vars;
12336 Vars.reserve(NumVars);
12337 for (unsigned I = 0; I != NumVars; ++I)
12338 Vars.push_back(Record.readSubExpr());
12339 C->setVarRefs(Vars);
12340 Vars.clear();
12341 for (unsigned I = 0; I != NumVars; ++I)
12342 Vars.push_back(Record.readSubExpr());
12343 C->setPrivates(Vars);
12344 Vars.clear();
12345 for (unsigned I = 0; I != NumVars; ++I)
12346 Vars.push_back(Record.readSubExpr());
12347 C->setLHSExprs(Vars);
12348 Vars.clear();
12349 for (unsigned I = 0; I != NumVars; ++I)
12350 Vars.push_back(Record.readSubExpr());
12351 C->setRHSExprs(Vars);
12352 Vars.clear();
12353 for (unsigned I = 0; I != NumVars; ++I)
12354 Vars.push_back(Record.readSubExpr());
12355 C->setReductionOps(Vars);
12356 Vars.clear();
12357 for (unsigned I = 0; I != NumVars; ++I)
12358 Vars.push_back(Record.readSubExpr());
12359 C->setTaskgroupDescriptors(Vars);
12360 }
12361
VisitOMPLinearClause(OMPLinearClause * C)12362 void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
12363 VisitOMPClauseWithPostUpdate(C);
12364 C->setLParenLoc(Record.readSourceLocation());
12365 C->setColonLoc(Record.readSourceLocation());
12366 C->setModifier(static_cast<OpenMPLinearClauseKind>(Record.readInt()));
12367 C->setModifierLoc(Record.readSourceLocation());
12368 unsigned NumVars = C->varlist_size();
12369 SmallVector<Expr *, 16> Vars;
12370 Vars.reserve(NumVars);
12371 for (unsigned i = 0; i != NumVars; ++i)
12372 Vars.push_back(Record.readSubExpr());
12373 C->setVarRefs(Vars);
12374 Vars.clear();
12375 for (unsigned i = 0; i != NumVars; ++i)
12376 Vars.push_back(Record.readSubExpr());
12377 C->setPrivates(Vars);
12378 Vars.clear();
12379 for (unsigned i = 0; i != NumVars; ++i)
12380 Vars.push_back(Record.readSubExpr());
12381 C->setInits(Vars);
12382 Vars.clear();
12383 for (unsigned i = 0; i != NumVars; ++i)
12384 Vars.push_back(Record.readSubExpr());
12385 C->setUpdates(Vars);
12386 Vars.clear();
12387 for (unsigned i = 0; i != NumVars; ++i)
12388 Vars.push_back(Record.readSubExpr());
12389 C->setFinals(Vars);
12390 C->setStep(Record.readSubExpr());
12391 C->setCalcStep(Record.readSubExpr());
12392 Vars.clear();
12393 for (unsigned I = 0; I != NumVars + 1; ++I)
12394 Vars.push_back(Record.readSubExpr());
12395 C->setUsedExprs(Vars);
12396 }
12397
VisitOMPAlignedClause(OMPAlignedClause * C)12398 void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
12399 C->setLParenLoc(Record.readSourceLocation());
12400 C->setColonLoc(Record.readSourceLocation());
12401 unsigned NumVars = C->varlist_size();
12402 SmallVector<Expr *, 16> Vars;
12403 Vars.reserve(NumVars);
12404 for (unsigned i = 0; i != NumVars; ++i)
12405 Vars.push_back(Record.readSubExpr());
12406 C->setVarRefs(Vars);
12407 C->setAlignment(Record.readSubExpr());
12408 }
12409
VisitOMPCopyinClause(OMPCopyinClause * C)12410 void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
12411 C->setLParenLoc(Record.readSourceLocation());
12412 unsigned NumVars = C->varlist_size();
12413 SmallVector<Expr *, 16> Exprs;
12414 Exprs.reserve(NumVars);
12415 for (unsigned i = 0; i != NumVars; ++i)
12416 Exprs.push_back(Record.readSubExpr());
12417 C->setVarRefs(Exprs);
12418 Exprs.clear();
12419 for (unsigned i = 0; i != NumVars; ++i)
12420 Exprs.push_back(Record.readSubExpr());
12421 C->setSourceExprs(Exprs);
12422 Exprs.clear();
12423 for (unsigned i = 0; i != NumVars; ++i)
12424 Exprs.push_back(Record.readSubExpr());
12425 C->setDestinationExprs(Exprs);
12426 Exprs.clear();
12427 for (unsigned i = 0; i != NumVars; ++i)
12428 Exprs.push_back(Record.readSubExpr());
12429 C->setAssignmentOps(Exprs);
12430 }
12431
VisitOMPCopyprivateClause(OMPCopyprivateClause * C)12432 void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
12433 C->setLParenLoc(Record.readSourceLocation());
12434 unsigned NumVars = C->varlist_size();
12435 SmallVector<Expr *, 16> Exprs;
12436 Exprs.reserve(NumVars);
12437 for (unsigned i = 0; i != NumVars; ++i)
12438 Exprs.push_back(Record.readSubExpr());
12439 C->setVarRefs(Exprs);
12440 Exprs.clear();
12441 for (unsigned i = 0; i != NumVars; ++i)
12442 Exprs.push_back(Record.readSubExpr());
12443 C->setSourceExprs(Exprs);
12444 Exprs.clear();
12445 for (unsigned i = 0; i != NumVars; ++i)
12446 Exprs.push_back(Record.readSubExpr());
12447 C->setDestinationExprs(Exprs);
12448 Exprs.clear();
12449 for (unsigned i = 0; i != NumVars; ++i)
12450 Exprs.push_back(Record.readSubExpr());
12451 C->setAssignmentOps(Exprs);
12452 }
12453
VisitOMPFlushClause(OMPFlushClause * C)12454 void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
12455 C->setLParenLoc(Record.readSourceLocation());
12456 unsigned NumVars = C->varlist_size();
12457 SmallVector<Expr *, 16> Vars;
12458 Vars.reserve(NumVars);
12459 for (unsigned i = 0; i != NumVars; ++i)
12460 Vars.push_back(Record.readSubExpr());
12461 C->setVarRefs(Vars);
12462 }
12463
VisitOMPDepobjClause(OMPDepobjClause * C)12464 void OMPClauseReader::VisitOMPDepobjClause(OMPDepobjClause *C) {
12465 C->setDepobj(Record.readSubExpr());
12466 C->setLParenLoc(Record.readSourceLocation());
12467 }
12468
VisitOMPDependClause(OMPDependClause * C)12469 void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
12470 C->setLParenLoc(Record.readSourceLocation());
12471 C->setModifier(Record.readSubExpr());
12472 C->setDependencyKind(
12473 static_cast<OpenMPDependClauseKind>(Record.readInt()));
12474 C->setDependencyLoc(Record.readSourceLocation());
12475 C->setColonLoc(Record.readSourceLocation());
12476 unsigned NumVars = C->varlist_size();
12477 SmallVector<Expr *, 16> Vars;
12478 Vars.reserve(NumVars);
12479 for (unsigned I = 0; I != NumVars; ++I)
12480 Vars.push_back(Record.readSubExpr());
12481 C->setVarRefs(Vars);
12482 for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
12483 C->setLoopData(I, Record.readSubExpr());
12484 }
12485
VisitOMPDeviceClause(OMPDeviceClause * C)12486 void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
12487 VisitOMPClauseWithPreInit(C);
12488 C->setModifier(Record.readEnum<OpenMPDeviceClauseModifier>());
12489 C->setDevice(Record.readSubExpr());
12490 C->setModifierLoc(Record.readSourceLocation());
12491 C->setLParenLoc(Record.readSourceLocation());
12492 }
12493
VisitOMPMapClause(OMPMapClause * C)12494 void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
12495 C->setLParenLoc(Record.readSourceLocation());
12496 for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) {
12497 C->setMapTypeModifier(
12498 I, static_cast<OpenMPMapModifierKind>(Record.readInt()));
12499 C->setMapTypeModifierLoc(I, Record.readSourceLocation());
12500 }
12501 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12502 C->setMapperIdInfo(Record.readDeclarationNameInfo());
12503 C->setMapType(
12504 static_cast<OpenMPMapClauseKind>(Record.readInt()));
12505 C->setMapLoc(Record.readSourceLocation());
12506 C->setColonLoc(Record.readSourceLocation());
12507 auto NumVars = C->varlist_size();
12508 auto UniqueDecls = C->getUniqueDeclarationsNum();
12509 auto TotalLists = C->getTotalComponentListNum();
12510 auto TotalComponents = C->getTotalComponentsNum();
12511
12512 SmallVector<Expr *, 16> Vars;
12513 Vars.reserve(NumVars);
12514 for (unsigned i = 0; i != NumVars; ++i)
12515 Vars.push_back(Record.readExpr());
12516 C->setVarRefs(Vars);
12517
12518 SmallVector<Expr *, 16> UDMappers;
12519 UDMappers.reserve(NumVars);
12520 for (unsigned I = 0; I < NumVars; ++I)
12521 UDMappers.push_back(Record.readExpr());
12522 C->setUDMapperRefs(UDMappers);
12523
12524 SmallVector<ValueDecl *, 16> Decls;
12525 Decls.reserve(UniqueDecls);
12526 for (unsigned i = 0; i < UniqueDecls; ++i)
12527 Decls.push_back(Record.readDeclAs<ValueDecl>());
12528 C->setUniqueDecls(Decls);
12529
12530 SmallVector<unsigned, 16> ListsPerDecl;
12531 ListsPerDecl.reserve(UniqueDecls);
12532 for (unsigned i = 0; i < UniqueDecls; ++i)
12533 ListsPerDecl.push_back(Record.readInt());
12534 C->setDeclNumLists(ListsPerDecl);
12535
12536 SmallVector<unsigned, 32> ListSizes;
12537 ListSizes.reserve(TotalLists);
12538 for (unsigned i = 0; i < TotalLists; ++i)
12539 ListSizes.push_back(Record.readInt());
12540 C->setComponentListSizes(ListSizes);
12541
12542 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12543 Components.reserve(TotalComponents);
12544 for (unsigned i = 0; i < TotalComponents; ++i) {
12545 Expr *AssociatedExpr = Record.readExpr();
12546 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12547 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12548 AssociatedExpr, AssociatedDecl));
12549 }
12550 C->setComponents(Components, ListSizes);
12551 }
12552
VisitOMPAllocateClause(OMPAllocateClause * C)12553 void OMPClauseReader::VisitOMPAllocateClause(OMPAllocateClause *C) {
12554 C->setLParenLoc(Record.readSourceLocation());
12555 C->setColonLoc(Record.readSourceLocation());
12556 C->setAllocator(Record.readSubExpr());
12557 unsigned NumVars = C->varlist_size();
12558 SmallVector<Expr *, 16> Vars;
12559 Vars.reserve(NumVars);
12560 for (unsigned i = 0; i != NumVars; ++i)
12561 Vars.push_back(Record.readSubExpr());
12562 C->setVarRefs(Vars);
12563 }
12564
VisitOMPNumTeamsClause(OMPNumTeamsClause * C)12565 void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
12566 VisitOMPClauseWithPreInit(C);
12567 C->setNumTeams(Record.readSubExpr());
12568 C->setLParenLoc(Record.readSourceLocation());
12569 }
12570
VisitOMPThreadLimitClause(OMPThreadLimitClause * C)12571 void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
12572 VisitOMPClauseWithPreInit(C);
12573 C->setThreadLimit(Record.readSubExpr());
12574 C->setLParenLoc(Record.readSourceLocation());
12575 }
12576
VisitOMPPriorityClause(OMPPriorityClause * C)12577 void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
12578 VisitOMPClauseWithPreInit(C);
12579 C->setPriority(Record.readSubExpr());
12580 C->setLParenLoc(Record.readSourceLocation());
12581 }
12582
VisitOMPGrainsizeClause(OMPGrainsizeClause * C)12583 void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
12584 VisitOMPClauseWithPreInit(C);
12585 C->setGrainsize(Record.readSubExpr());
12586 C->setLParenLoc(Record.readSourceLocation());
12587 }
12588
VisitOMPNumTasksClause(OMPNumTasksClause * C)12589 void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
12590 VisitOMPClauseWithPreInit(C);
12591 C->setNumTasks(Record.readSubExpr());
12592 C->setLParenLoc(Record.readSourceLocation());
12593 }
12594
VisitOMPHintClause(OMPHintClause * C)12595 void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
12596 C->setHint(Record.readSubExpr());
12597 C->setLParenLoc(Record.readSourceLocation());
12598 }
12599
VisitOMPDistScheduleClause(OMPDistScheduleClause * C)12600 void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
12601 VisitOMPClauseWithPreInit(C);
12602 C->setDistScheduleKind(
12603 static_cast<OpenMPDistScheduleClauseKind>(Record.readInt()));
12604 C->setChunkSize(Record.readSubExpr());
12605 C->setLParenLoc(Record.readSourceLocation());
12606 C->setDistScheduleKindLoc(Record.readSourceLocation());
12607 C->setCommaLoc(Record.readSourceLocation());
12608 }
12609
VisitOMPDefaultmapClause(OMPDefaultmapClause * C)12610 void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
12611 C->setDefaultmapKind(
12612 static_cast<OpenMPDefaultmapClauseKind>(Record.readInt()));
12613 C->setDefaultmapModifier(
12614 static_cast<OpenMPDefaultmapClauseModifier>(Record.readInt()));
12615 C->setLParenLoc(Record.readSourceLocation());
12616 C->setDefaultmapModifierLoc(Record.readSourceLocation());
12617 C->setDefaultmapKindLoc(Record.readSourceLocation());
12618 }
12619
VisitOMPToClause(OMPToClause * C)12620 void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
12621 C->setLParenLoc(Record.readSourceLocation());
12622 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12623 C->setMapperIdInfo(Record.readDeclarationNameInfo());
12624 auto NumVars = C->varlist_size();
12625 auto UniqueDecls = C->getUniqueDeclarationsNum();
12626 auto TotalLists = C->getTotalComponentListNum();
12627 auto TotalComponents = C->getTotalComponentsNum();
12628
12629 SmallVector<Expr *, 16> Vars;
12630 Vars.reserve(NumVars);
12631 for (unsigned i = 0; i != NumVars; ++i)
12632 Vars.push_back(Record.readSubExpr());
12633 C->setVarRefs(Vars);
12634
12635 SmallVector<Expr *, 16> UDMappers;
12636 UDMappers.reserve(NumVars);
12637 for (unsigned I = 0; I < NumVars; ++I)
12638 UDMappers.push_back(Record.readSubExpr());
12639 C->setUDMapperRefs(UDMappers);
12640
12641 SmallVector<ValueDecl *, 16> Decls;
12642 Decls.reserve(UniqueDecls);
12643 for (unsigned i = 0; i < UniqueDecls; ++i)
12644 Decls.push_back(Record.readDeclAs<ValueDecl>());
12645 C->setUniqueDecls(Decls);
12646
12647 SmallVector<unsigned, 16> ListsPerDecl;
12648 ListsPerDecl.reserve(UniqueDecls);
12649 for (unsigned i = 0; i < UniqueDecls; ++i)
12650 ListsPerDecl.push_back(Record.readInt());
12651 C->setDeclNumLists(ListsPerDecl);
12652
12653 SmallVector<unsigned, 32> ListSizes;
12654 ListSizes.reserve(TotalLists);
12655 for (unsigned i = 0; i < TotalLists; ++i)
12656 ListSizes.push_back(Record.readInt());
12657 C->setComponentListSizes(ListSizes);
12658
12659 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12660 Components.reserve(TotalComponents);
12661 for (unsigned i = 0; i < TotalComponents; ++i) {
12662 Expr *AssociatedExpr = Record.readSubExpr();
12663 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12664 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12665 AssociatedExpr, AssociatedDecl));
12666 }
12667 C->setComponents(Components, ListSizes);
12668 }
12669
VisitOMPFromClause(OMPFromClause * C)12670 void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
12671 C->setLParenLoc(Record.readSourceLocation());
12672 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12673 C->setMapperIdInfo(Record.readDeclarationNameInfo());
12674 auto NumVars = C->varlist_size();
12675 auto UniqueDecls = C->getUniqueDeclarationsNum();
12676 auto TotalLists = C->getTotalComponentListNum();
12677 auto TotalComponents = C->getTotalComponentsNum();
12678
12679 SmallVector<Expr *, 16> Vars;
12680 Vars.reserve(NumVars);
12681 for (unsigned i = 0; i != NumVars; ++i)
12682 Vars.push_back(Record.readSubExpr());
12683 C->setVarRefs(Vars);
12684
12685 SmallVector<Expr *, 16> UDMappers;
12686 UDMappers.reserve(NumVars);
12687 for (unsigned I = 0; I < NumVars; ++I)
12688 UDMappers.push_back(Record.readSubExpr());
12689 C->setUDMapperRefs(UDMappers);
12690
12691 SmallVector<ValueDecl *, 16> Decls;
12692 Decls.reserve(UniqueDecls);
12693 for (unsigned i = 0; i < UniqueDecls; ++i)
12694 Decls.push_back(Record.readDeclAs<ValueDecl>());
12695 C->setUniqueDecls(Decls);
12696
12697 SmallVector<unsigned, 16> ListsPerDecl;
12698 ListsPerDecl.reserve(UniqueDecls);
12699 for (unsigned i = 0; i < UniqueDecls; ++i)
12700 ListsPerDecl.push_back(Record.readInt());
12701 C->setDeclNumLists(ListsPerDecl);
12702
12703 SmallVector<unsigned, 32> ListSizes;
12704 ListSizes.reserve(TotalLists);
12705 for (unsigned i = 0; i < TotalLists; ++i)
12706 ListSizes.push_back(Record.readInt());
12707 C->setComponentListSizes(ListSizes);
12708
12709 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12710 Components.reserve(TotalComponents);
12711 for (unsigned i = 0; i < TotalComponents; ++i) {
12712 Expr *AssociatedExpr = Record.readSubExpr();
12713 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12714 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12715 AssociatedExpr, AssociatedDecl));
12716 }
12717 C->setComponents(Components, ListSizes);
12718 }
12719
VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause * C)12720 void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
12721 C->setLParenLoc(Record.readSourceLocation());
12722 auto NumVars = C->varlist_size();
12723 auto UniqueDecls = C->getUniqueDeclarationsNum();
12724 auto TotalLists = C->getTotalComponentListNum();
12725 auto TotalComponents = C->getTotalComponentsNum();
12726
12727 SmallVector<Expr *, 16> Vars;
12728 Vars.reserve(NumVars);
12729 for (unsigned i = 0; i != NumVars; ++i)
12730 Vars.push_back(Record.readSubExpr());
12731 C->setVarRefs(Vars);
12732 Vars.clear();
12733 for (unsigned i = 0; i != NumVars; ++i)
12734 Vars.push_back(Record.readSubExpr());
12735 C->setPrivateCopies(Vars);
12736 Vars.clear();
12737 for (unsigned i = 0; i != NumVars; ++i)
12738 Vars.push_back(Record.readSubExpr());
12739 C->setInits(Vars);
12740
12741 SmallVector<ValueDecl *, 16> Decls;
12742 Decls.reserve(UniqueDecls);
12743 for (unsigned i = 0; i < UniqueDecls; ++i)
12744 Decls.push_back(Record.readDeclAs<ValueDecl>());
12745 C->setUniqueDecls(Decls);
12746
12747 SmallVector<unsigned, 16> ListsPerDecl;
12748 ListsPerDecl.reserve(UniqueDecls);
12749 for (unsigned i = 0; i < UniqueDecls; ++i)
12750 ListsPerDecl.push_back(Record.readInt());
12751 C->setDeclNumLists(ListsPerDecl);
12752
12753 SmallVector<unsigned, 32> ListSizes;
12754 ListSizes.reserve(TotalLists);
12755 for (unsigned i = 0; i < TotalLists; ++i)
12756 ListSizes.push_back(Record.readInt());
12757 C->setComponentListSizes(ListSizes);
12758
12759 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12760 Components.reserve(TotalComponents);
12761 for (unsigned i = 0; i < TotalComponents; ++i) {
12762 Expr *AssociatedExpr = Record.readSubExpr();
12763 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12764 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12765 AssociatedExpr, AssociatedDecl));
12766 }
12767 C->setComponents(Components, ListSizes);
12768 }
12769
VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause * C)12770 void OMPClauseReader::VisitOMPUseDeviceAddrClause(OMPUseDeviceAddrClause *C) {
12771 C->setLParenLoc(Record.readSourceLocation());
12772 auto NumVars = C->varlist_size();
12773 auto UniqueDecls = C->getUniqueDeclarationsNum();
12774 auto TotalLists = C->getTotalComponentListNum();
12775 auto TotalComponents = C->getTotalComponentsNum();
12776
12777 SmallVector<Expr *, 16> Vars;
12778 Vars.reserve(NumVars);
12779 for (unsigned i = 0; i != NumVars; ++i)
12780 Vars.push_back(Record.readSubExpr());
12781 C->setVarRefs(Vars);
12782
12783 SmallVector<ValueDecl *, 16> Decls;
12784 Decls.reserve(UniqueDecls);
12785 for (unsigned i = 0; i < UniqueDecls; ++i)
12786 Decls.push_back(Record.readDeclAs<ValueDecl>());
12787 C->setUniqueDecls(Decls);
12788
12789 SmallVector<unsigned, 16> ListsPerDecl;
12790 ListsPerDecl.reserve(UniqueDecls);
12791 for (unsigned i = 0; i < UniqueDecls; ++i)
12792 ListsPerDecl.push_back(Record.readInt());
12793 C->setDeclNumLists(ListsPerDecl);
12794
12795 SmallVector<unsigned, 32> ListSizes;
12796 ListSizes.reserve(TotalLists);
12797 for (unsigned i = 0; i < TotalLists; ++i)
12798 ListSizes.push_back(Record.readInt());
12799 C->setComponentListSizes(ListSizes);
12800
12801 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12802 Components.reserve(TotalComponents);
12803 for (unsigned i = 0; i < TotalComponents; ++i) {
12804 Expr *AssociatedExpr = Record.readSubExpr();
12805 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12806 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12807 AssociatedExpr, AssociatedDecl));
12808 }
12809 C->setComponents(Components, ListSizes);
12810 }
12811
VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause * C)12812 void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
12813 C->setLParenLoc(Record.readSourceLocation());
12814 auto NumVars = C->varlist_size();
12815 auto UniqueDecls = C->getUniqueDeclarationsNum();
12816 auto TotalLists = C->getTotalComponentListNum();
12817 auto TotalComponents = C->getTotalComponentsNum();
12818
12819 SmallVector<Expr *, 16> Vars;
12820 Vars.reserve(NumVars);
12821 for (unsigned i = 0; i != NumVars; ++i)
12822 Vars.push_back(Record.readSubExpr());
12823 C->setVarRefs(Vars);
12824 Vars.clear();
12825
12826 SmallVector<ValueDecl *, 16> Decls;
12827 Decls.reserve(UniqueDecls);
12828 for (unsigned i = 0; i < UniqueDecls; ++i)
12829 Decls.push_back(Record.readDeclAs<ValueDecl>());
12830 C->setUniqueDecls(Decls);
12831
12832 SmallVector<unsigned, 16> ListsPerDecl;
12833 ListsPerDecl.reserve(UniqueDecls);
12834 for (unsigned i = 0; i < UniqueDecls; ++i)
12835 ListsPerDecl.push_back(Record.readInt());
12836 C->setDeclNumLists(ListsPerDecl);
12837
12838 SmallVector<unsigned, 32> ListSizes;
12839 ListSizes.reserve(TotalLists);
12840 for (unsigned i = 0; i < TotalLists; ++i)
12841 ListSizes.push_back(Record.readInt());
12842 C->setComponentListSizes(ListSizes);
12843
12844 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12845 Components.reserve(TotalComponents);
12846 for (unsigned i = 0; i < TotalComponents; ++i) {
12847 Expr *AssociatedExpr = Record.readSubExpr();
12848 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12849 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12850 AssociatedExpr, AssociatedDecl));
12851 }
12852 C->setComponents(Components, ListSizes);
12853 }
12854
VisitOMPNontemporalClause(OMPNontemporalClause * C)12855 void OMPClauseReader::VisitOMPNontemporalClause(OMPNontemporalClause *C) {
12856 C->setLParenLoc(Record.readSourceLocation());
12857 unsigned NumVars = C->varlist_size();
12858 SmallVector<Expr *, 16> Vars;
12859 Vars.reserve(NumVars);
12860 for (unsigned i = 0; i != NumVars; ++i)
12861 Vars.push_back(Record.readSubExpr());
12862 C->setVarRefs(Vars);
12863 Vars.clear();
12864 Vars.reserve(NumVars);
12865 for (unsigned i = 0; i != NumVars; ++i)
12866 Vars.push_back(Record.readSubExpr());
12867 C->setPrivateRefs(Vars);
12868 }
12869
VisitOMPInclusiveClause(OMPInclusiveClause * C)12870 void OMPClauseReader::VisitOMPInclusiveClause(OMPInclusiveClause *C) {
12871 C->setLParenLoc(Record.readSourceLocation());
12872 unsigned NumVars = C->varlist_size();
12873 SmallVector<Expr *, 16> Vars;
12874 Vars.reserve(NumVars);
12875 for (unsigned i = 0; i != NumVars; ++i)
12876 Vars.push_back(Record.readSubExpr());
12877 C->setVarRefs(Vars);
12878 }
12879
VisitOMPExclusiveClause(OMPExclusiveClause * C)12880 void OMPClauseReader::VisitOMPExclusiveClause(OMPExclusiveClause *C) {
12881 C->setLParenLoc(Record.readSourceLocation());
12882 unsigned NumVars = C->varlist_size();
12883 SmallVector<Expr *, 16> Vars;
12884 Vars.reserve(NumVars);
12885 for (unsigned i = 0; i != NumVars; ++i)
12886 Vars.push_back(Record.readSubExpr());
12887 C->setVarRefs(Vars);
12888 }
12889
VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause * C)12890 void OMPClauseReader::VisitOMPUsesAllocatorsClause(OMPUsesAllocatorsClause *C) {
12891 C->setLParenLoc(Record.readSourceLocation());
12892 unsigned NumOfAllocators = C->getNumberOfAllocators();
12893 SmallVector<OMPUsesAllocatorsClause::Data, 4> Data;
12894 Data.reserve(NumOfAllocators);
12895 for (unsigned I = 0; I != NumOfAllocators; ++I) {
12896 OMPUsesAllocatorsClause::Data &D = Data.emplace_back();
12897 D.Allocator = Record.readSubExpr();
12898 D.AllocatorTraits = Record.readSubExpr();
12899 D.LParenLoc = Record.readSourceLocation();
12900 D.RParenLoc = Record.readSourceLocation();
12901 }
12902 C->setAllocatorsData(Data);
12903 }
12904
VisitOMPAffinityClause(OMPAffinityClause * C)12905 void OMPClauseReader::VisitOMPAffinityClause(OMPAffinityClause *C) {
12906 C->setLParenLoc(Record.readSourceLocation());
12907 C->setModifier(Record.readSubExpr());
12908 C->setColonLoc(Record.readSourceLocation());
12909 unsigned NumOfLocators = C->varlist_size();
12910 SmallVector<Expr *, 4> Locators;
12911 Locators.reserve(NumOfLocators);
12912 for (unsigned I = 0; I != NumOfLocators; ++I)
12913 Locators.push_back(Record.readSubExpr());
12914 C->setVarRefs(Locators);
12915 }
12916
VisitOMPOrderClause(OMPOrderClause * C)12917 void OMPClauseReader::VisitOMPOrderClause(OMPOrderClause *C) {
12918 C->setKind(Record.readEnum<OpenMPOrderClauseKind>());
12919 C->setLParenLoc(Record.readSourceLocation());
12920 C->setKindKwLoc(Record.readSourceLocation());
12921 }
12922
readOMPTraitInfo()12923 OMPTraitInfo *ASTRecordReader::readOMPTraitInfo() {
12924 OMPTraitInfo &TI = getContext().getNewOMPTraitInfo();
12925 TI.Sets.resize(readUInt32());
12926 for (auto &Set : TI.Sets) {
12927 Set.Kind = readEnum<llvm::omp::TraitSet>();
12928 Set.Selectors.resize(readUInt32());
12929 for (auto &Selector : Set.Selectors) {
12930 Selector.Kind = readEnum<llvm::omp::TraitSelector>();
12931 Selector.ScoreOrCondition = nullptr;
12932 if (readBool())
12933 Selector.ScoreOrCondition = readExprRef();
12934 Selector.Properties.resize(readUInt32());
12935 for (auto &Property : Selector.Properties)
12936 Property.Kind = readEnum<llvm::omp::TraitProperty>();
12937 }
12938 }
12939 return &TI;
12940 }
12941