Bug Summary

File:tools/clang/lib/Serialization/ASTReader.cpp
Warning:line 8805, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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