Bug Summary

File:clang/include/clang/AST/OpenMPClause.h
Warning:line 8424, column 13
Called C++ object pointer is null

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-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Serialization -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D 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-14/lib/clang/14.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-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Serialization -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -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-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Serialization/ASTReader.cpp

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