Bug Summary

File:llvm/include/llvm/Bitstream/BitstreamReader.h
Warning:line 221, column 39
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTReader.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/build-llvm/tools/clang/lib/Serialization -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/build-llvm/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/clang/include -I /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/build-llvm/tools/clang/lib/Serialization -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-06-13-111025-38230-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/clang/lib/Serialization/ASTReader.cpp

/build/llvm-toolchain-snapshot-13~++20210613111130+5be314f79ba7/clang/lib/Serialization/ASTReader.cpp

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