Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTReader.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -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-9/lib/clang/9.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.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-9~svn362543/build-llvm/tools/clang/lib/Serialization -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp

1//===- ASTReader.cpp - AST File Reader ------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the ASTReader class, which reads AST files.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/Serialization/ASTReader.h"
14#include "ASTCommon.h"
15#include "ASTReaderInternals.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/ASTMutationListener.h"
19#include "clang/AST/ASTUnresolvedSet.h"
20#include "clang/AST/Decl.h"
21#include "clang/AST/DeclBase.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclFriend.h"
24#include "clang/AST/DeclGroup.h"
25#include "clang/AST/DeclObjC.h"
26#include "clang/AST/DeclTemplate.h"
27#include "clang/AST/DeclarationName.h"
28#include "clang/AST/Expr.h"
29#include "clang/AST/ExprCXX.h"
30#include "clang/AST/ExternalASTSource.h"
31#include "clang/AST/NestedNameSpecifier.h"
32#include "clang/AST/ODRHash.h"
33#include "clang/AST/RawCommentList.h"
34#include "clang/AST/TemplateBase.h"
35#include "clang/AST/TemplateName.h"
36#include "clang/AST/Type.h"
37#include "clang/AST/TypeLoc.h"
38#include "clang/AST/TypeLocVisitor.h"
39#include "clang/AST/UnresolvedSet.h"
40#include "clang/Basic/CommentOptions.h"
41#include "clang/Basic/Diagnostic.h"
42#include "clang/Basic/DiagnosticOptions.h"
43#include "clang/Basic/ExceptionSpecificationType.h"
44#include "clang/Basic/FileManager.h"
45#include "clang/Basic/FileSystemOptions.h"
46#include "clang/Basic/IdentifierTable.h"
47#include "clang/Basic/LLVM.h"
48#include "clang/Basic/LangOptions.h"
49#include "clang/Basic/Module.h"
50#include "clang/Basic/ObjCRuntime.h"
51#include "clang/Basic/OperatorKinds.h"
52#include "clang/Basic/PragmaKinds.h"
53#include "clang/Basic/Sanitizers.h"
54#include "clang/Basic/SourceLocation.h"
55#include "clang/Basic/SourceManager.h"
56#include "clang/Basic/SourceManagerInternals.h"
57#include "clang/Basic/Specifiers.h"
58#include "clang/Basic/TargetInfo.h"
59#include "clang/Basic/TargetOptions.h"
60#include "clang/Basic/TokenKinds.h"
61#include "clang/Basic/Version.h"
62#include "clang/Lex/HeaderSearch.h"
63#include "clang/Lex/HeaderSearchOptions.h"
64#include "clang/Lex/MacroInfo.h"
65#include "clang/Lex/ModuleMap.h"
66#include "clang/Lex/PreprocessingRecord.h"
67#include "clang/Lex/Preprocessor.h"
68#include "clang/Lex/PreprocessorOptions.h"
69#include "clang/Lex/Token.h"
70#include "clang/Sema/ObjCMethodList.h"
71#include "clang/Sema/Scope.h"
72#include "clang/Sema/Sema.h"
73#include "clang/Sema/Weak.h"
74#include "clang/Serialization/ASTBitCodes.h"
75#include "clang/Serialization/ASTDeserializationListener.h"
76#include "clang/Serialization/ContinuousRangeMap.h"
77#include "clang/Serialization/GlobalModuleIndex.h"
78#include "clang/Serialization/InMemoryModuleCache.h"
79#include "clang/Serialization/Module.h"
80#include "clang/Serialization/ModuleFileExtension.h"
81#include "clang/Serialization/ModuleManager.h"
82#include "clang/Serialization/PCHContainerOperations.h"
83#include "clang/Serialization/SerializationDiagnostic.h"
84#include "llvm/ADT/APFloat.h"
85#include "llvm/ADT/APInt.h"
86#include "llvm/ADT/APSInt.h"
87#include "llvm/ADT/ArrayRef.h"
88#include "llvm/ADT/DenseMap.h"
89#include "llvm/ADT/FoldingSet.h"
90#include "llvm/ADT/Hashing.h"
91#include "llvm/ADT/IntrusiveRefCntPtr.h"
92#include "llvm/ADT/None.h"
93#include "llvm/ADT/Optional.h"
94#include "llvm/ADT/STLExtras.h"
95#include "llvm/ADT/ScopeExit.h"
96#include "llvm/ADT/SmallPtrSet.h"
97#include "llvm/ADT/SmallString.h"
98#include "llvm/ADT/SmallVector.h"
99#include "llvm/ADT/StringExtras.h"
100#include "llvm/ADT/StringMap.h"
101#include "llvm/ADT/StringRef.h"
102#include "llvm/ADT/Triple.h"
103#include "llvm/ADT/iterator_range.h"
104#include "llvm/Bitcode/BitstreamReader.h"
105#include "llvm/Support/Casting.h"
106#include "llvm/Support/Compiler.h"
107#include "llvm/Support/Compression.h"
108#include "llvm/Support/DJB.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/VersionTuple.h"
118#include "llvm/Support/raw_ostream.h"
119#include <algorithm>
120#include <cassert>
121#include <cstddef>
122#include <cstdint>
123#include <cstdio>
124#include <ctime>
125#include <iterator>
126#include <limits>
127#include <map>
128#include <memory>
129#include <string>
130#include <system_error>
131#include <tuple>
132#include <utility>
133#include <vector>
134
135using namespace clang;
136using namespace clang::serialization;
137using namespace clang::serialization::reader;
138using llvm::BitstreamCursor;
139
140//===----------------------------------------------------------------------===//
141// ChainedASTReaderListener implementation
142//===----------------------------------------------------------------------===//
143
144bool
145ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
146 return First->ReadFullVersionInformation(FullVersion) ||
147 Second->ReadFullVersionInformation(FullVersion);
148}
149
150void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
151 First->ReadModuleName(ModuleName);
152 Second->ReadModuleName(ModuleName);
153}
154
155void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
156 First->ReadModuleMapFile(ModuleMapPath);
157 Second->ReadModuleMapFile(ModuleMapPath);
158}
159
160bool
161ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
162 bool Complain,
163 bool AllowCompatibleDifferences) {
164 return First->ReadLanguageOptions(LangOpts, Complain,
165 AllowCompatibleDifferences) ||
166 Second->ReadLanguageOptions(LangOpts, Complain,
167 AllowCompatibleDifferences);
168}
169
170bool ChainedASTReaderListener::ReadTargetOptions(
171 const TargetOptions &TargetOpts, bool Complain,
172 bool AllowCompatibleDifferences) {
173 return First->ReadTargetOptions(TargetOpts, Complain,
174 AllowCompatibleDifferences) ||
175 Second->ReadTargetOptions(TargetOpts, Complain,
176 AllowCompatibleDifferences);
177}
178
179bool ChainedASTReaderListener::ReadDiagnosticOptions(
180 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
181 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
182 Second->ReadDiagnosticOptions(DiagOpts, Complain);
183}
184
185bool
186ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
187 bool Complain) {
188 return First->ReadFileSystemOptions(FSOpts, Complain) ||
189 Second->ReadFileSystemOptions(FSOpts, Complain);
190}
191
192bool ChainedASTReaderListener::ReadHeaderSearchOptions(
193 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
194 bool Complain) {
195 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
196 Complain) ||
197 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
198 Complain);
199}
200
201bool ChainedASTReaderListener::ReadPreprocessorOptions(
202 const PreprocessorOptions &PPOpts, bool Complain,
203 std::string &SuggestedPredefines) {
204 return First->ReadPreprocessorOptions(PPOpts, Complain,
205 SuggestedPredefines) ||
206 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
207}
208
209void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
210 unsigned Value) {
211 First->ReadCounter(M, Value);
212 Second->ReadCounter(M, Value);
213}
214
215bool ChainedASTReaderListener::needsInputFileVisitation() {
216 return First->needsInputFileVisitation() ||
217 Second->needsInputFileVisitation();
218}
219
220bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
221 return First->needsSystemInputFileVisitation() ||
222 Second->needsSystemInputFileVisitation();
223}
224
225void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
226 ModuleKind Kind) {
227 First->visitModuleFile(Filename, Kind);
228 Second->visitModuleFile(Filename, Kind);
229}
230
231bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
232 bool isSystem,
233 bool isOverridden,
234 bool isExplicitModule) {
235 bool Continue = false;
236 if (First->needsInputFileVisitation() &&
237 (!isSystem || First->needsSystemInputFileVisitation()))
238 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
239 isExplicitModule);
240 if (Second->needsInputFileVisitation() &&
241 (!isSystem || Second->needsSystemInputFileVisitation()))
242 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
243 isExplicitModule);
244 return Continue;
245}
246
247void ChainedASTReaderListener::readModuleFileExtension(
248 const ModuleFileExtensionMetadata &Metadata) {
249 First->readModuleFileExtension(Metadata);
250 Second->readModuleFileExtension(Metadata);
251}
252
253//===----------------------------------------------------------------------===//
254// PCH validator implementation
255//===----------------------------------------------------------------------===//
256
257ASTReaderListener::~ASTReaderListener() = default;
258
259/// Compare the given set of language options against an existing set of
260/// language options.
261///
262/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
263/// \param AllowCompatibleDifferences If true, differences between compatible
264/// language options will be permitted.
265///
266/// \returns true if the languagae options mis-match, false otherwise.
267static bool checkLanguageOptions(const LangOptions &LangOpts,
268 const LangOptions &ExistingLangOpts,
269 DiagnosticsEngine *Diags,
270 bool AllowCompatibleDifferences = true) {
271#define LANGOPT(Name, Bits, Default, Description) \
272 if (ExistingLangOpts.Name != LangOpts.Name) { \
273 if (Diags) \
274 Diags->Report(diag::err_pch_langopt_mismatch) \
275 << Description << LangOpts.Name << ExistingLangOpts.Name; \
276 return true; \
277 }
278
279#define VALUE_LANGOPT(Name, Bits, Default, Description) \
280 if (ExistingLangOpts.Name != LangOpts.Name) { \
281 if (Diags) \
282 Diags->Report(diag::err_pch_langopt_value_mismatch) \
283 << Description; \
284 return true; \
285 }
286
287#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
288 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
289 if (Diags) \
290 Diags->Report(diag::err_pch_langopt_value_mismatch) \
291 << Description; \
292 return true; \
293 }
294
295#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
296 if (!AllowCompatibleDifferences) \
297 LANGOPT(Name, Bits, Default, Description)
298
299#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
300 if (!AllowCompatibleDifferences) \
301 ENUM_LANGOPT(Name, Bits, Default, Description)
302
303#define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
304 if (!AllowCompatibleDifferences) \
305 VALUE_LANGOPT(Name, Bits, Default, Description)
306
307#define BENIGN_LANGOPT(Name, Bits, Default, Description)
308#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
309#define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
310#include "clang/Basic/LangOptions.def"
311
312 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
313 if (Diags)
314 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
315 return true;
316 }
317
318 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
319 if (Diags)
320 Diags->Report(diag::err_pch_langopt_value_mismatch)
321 << "target Objective-C runtime";
322 return true;
323 }
324
325 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
326 LangOpts.CommentOpts.BlockCommandNames) {
327 if (Diags)
328 Diags->Report(diag::err_pch_langopt_value_mismatch)
329 << "block command names";
330 return true;
331 }
332
333 // Sanitizer feature mismatches are treated as compatible differences. If
334 // compatible differences aren't allowed, we still only want to check for
335 // mismatches of non-modular sanitizers (the only ones which can affect AST
336 // generation).
337 if (!AllowCompatibleDifferences) {
338 SanitizerMask ModularSanitizers = getPPTransparentSanitizers();
339 SanitizerSet ExistingSanitizers = ExistingLangOpts.Sanitize;
340 SanitizerSet ImportedSanitizers = LangOpts.Sanitize;
341 ExistingSanitizers.clear(ModularSanitizers);
342 ImportedSanitizers.clear(ModularSanitizers);
343 if (ExistingSanitizers.Mask != ImportedSanitizers.Mask) {
344 const std::string Flag = "-fsanitize=";
345 if (Diags) {
346#define SANITIZER(NAME, ID) \
347 { \
348 bool InExistingModule = ExistingSanitizers.has(SanitizerKind::ID); \
349 bool InImportedModule = ImportedSanitizers.has(SanitizerKind::ID); \
350 if (InExistingModule != InImportedModule) \
351 Diags->Report(diag::err_pch_targetopt_feature_mismatch) \
352 << InExistingModule << (Flag + NAME); \
353 }
354#include "clang/Basic/Sanitizers.def"
355 }
356 return true;
357 }
358 }
359
360 return false;
361}
362
363/// Compare the given set of target options against an existing set of
364/// target options.
365///
366/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
367///
368/// \returns true if the target options mis-match, false otherwise.
369static bool checkTargetOptions(const TargetOptions &TargetOpts,
370 const TargetOptions &ExistingTargetOpts,
371 DiagnosticsEngine *Diags,
372 bool AllowCompatibleDifferences = true) {
373#define CHECK_TARGET_OPT(Field, Name) \
374 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
375 if (Diags) \
376 Diags->Report(diag::err_pch_targetopt_mismatch) \
377 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
378 return true; \
379 }
380
381 // The triple and ABI must match exactly.
382 CHECK_TARGET_OPT(Triple, "target");
383 CHECK_TARGET_OPT(ABI, "target ABI");
384
385 // We can tolerate different CPUs in many cases, notably when one CPU
386 // supports a strict superset of another. When allowing compatible
387 // differences skip this check.
388 if (!AllowCompatibleDifferences)
389 CHECK_TARGET_OPT(CPU, "target CPU");
390
391#undef CHECK_TARGET_OPT
392
393 // Compare feature sets.
394 SmallVector<StringRef, 4> ExistingFeatures(
395 ExistingTargetOpts.FeaturesAsWritten.begin(),
396 ExistingTargetOpts.FeaturesAsWritten.end());
397 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
398 TargetOpts.FeaturesAsWritten.end());
399 llvm::sort(ExistingFeatures);
400 llvm::sort(ReadFeatures);
401
402 // We compute the set difference in both directions explicitly so that we can
403 // diagnose the differences differently.
404 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
405 std::set_difference(
406 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
407 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
408 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
409 ExistingFeatures.begin(), ExistingFeatures.end(),
410 std::back_inserter(UnmatchedReadFeatures));
411
412 // If we are allowing compatible differences and the read feature set is
413 // a strict subset of the existing feature set, there is nothing to diagnose.
414 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
415 return false;
416
417 if (Diags) {
418 for (StringRef Feature : UnmatchedReadFeatures)
419 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
420 << /* is-existing-feature */ false << Feature;
421 for (StringRef Feature : UnmatchedExistingFeatures)
422 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
423 << /* is-existing-feature */ true << Feature;
424 }
425
426 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
427}
428
429bool
430PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
431 bool Complain,
432 bool AllowCompatibleDifferences) {
433 const LangOptions &ExistingLangOpts = PP.getLangOpts();
434 return checkLanguageOptions(LangOpts, ExistingLangOpts,
435 Complain ? &Reader.Diags : nullptr,
436 AllowCompatibleDifferences);
437}
438
439bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
440 bool Complain,
441 bool AllowCompatibleDifferences) {
442 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
443 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
444 Complain ? &Reader.Diags : nullptr,
445 AllowCompatibleDifferences);
446}
447
448namespace {
449
450using MacroDefinitionsMap =
451 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>;
452using DeclsMap = llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8>>;
453
454} // namespace
455
456static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
457 DiagnosticsEngine &Diags,
458 bool Complain) {
459 using Level = DiagnosticsEngine::Level;
460
461 // Check current mappings for new -Werror mappings, and the stored mappings
462 // for cases that were explicitly mapped to *not* be errors that are now
463 // errors because of options like -Werror.
464 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
465
466 for (DiagnosticsEngine *MappingSource : MappingSources) {
467 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
468 diag::kind DiagID = DiagIDMappingPair.first;
469 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
470 if (CurLevel < DiagnosticsEngine::Error)
471 continue; // not significant
472 Level StoredLevel =
473 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
474 if (StoredLevel < DiagnosticsEngine::Error) {
475 if (Complain)
476 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
477 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
478 return true;
479 }
480 }
481 }
482
483 return false;
484}
485
486static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
487 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
488 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
489 return true;
490 return Ext >= diag::Severity::Error;
491}
492
493static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
494 DiagnosticsEngine &Diags,
495 bool IsSystem, bool Complain) {
496 // Top-level options
497 if (IsSystem) {
498 if (Diags.getSuppressSystemWarnings())
499 return false;
500 // If -Wsystem-headers was not enabled before, be conservative
501 if (StoredDiags.getSuppressSystemWarnings()) {
502 if (Complain)
503 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
504 return true;
505 }
506 }
507
508 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
509 if (Complain)
510 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
511 return true;
512 }
513
514 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
515 !StoredDiags.getEnableAllWarnings()) {
516 if (Complain)
517 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
518 return true;
519 }
520
521 if (isExtHandlingFromDiagsError(Diags) &&
522 !isExtHandlingFromDiagsError(StoredDiags)) {
523 if (Complain)
524 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
525 return true;
526 }
527
528 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
529}
530
531/// Return the top import module if it is implicit, nullptr otherwise.
532static Module *getTopImportImplicitModule(ModuleManager &ModuleMgr,
533 Preprocessor &PP) {
534 // If the original import came from a file explicitly generated by the user,
535 // don't check the diagnostic mappings.
536 // FIXME: currently this is approximated by checking whether this is not a
537 // module import of an implicitly-loaded module file.
538 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
539 // the transitive closure of its imports, since unrelated modules cannot be
540 // imported until after this module finishes validation.
541 ModuleFile *TopImport = &*ModuleMgr.rbegin();
542 while (!TopImport->ImportedBy.empty())
543 TopImport = TopImport->ImportedBy[0];
544 if (TopImport->Kind != MK_ImplicitModule)
545 return nullptr;
546
547 StringRef ModuleName = TopImport->ModuleName;
548 assert(!ModuleName.empty() && "diagnostic options read before module name")((!ModuleName.empty() && "diagnostic options read before module name"
) ? static_cast<void> (0) : __assert_fail ("!ModuleName.empty() && \"diagnostic options read before module name\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 548, __PRETTY_FUNCTION__))
;
549
550 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
551 assert(M && "missing module")((M && "missing module") ? static_cast<void> (0
) : __assert_fail ("M && \"missing module\"", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 551, __PRETTY_FUNCTION__))
;
552 return M;
553}
554
555bool PCHValidator::ReadDiagnosticOptions(
556 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
557 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
558 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
559 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
560 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
561 // This should never fail, because we would have processed these options
562 // before writing them to an ASTFile.
563 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
564
565 ModuleManager &ModuleMgr = Reader.getModuleManager();
566 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then")((ModuleMgr.size() >= 1 && "what ASTFile is this then"
) ? static_cast<void> (0) : __assert_fail ("ModuleMgr.size() >= 1 && \"what ASTFile is this then\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 566, __PRETTY_FUNCTION__))
;
567
568 Module *TopM = getTopImportImplicitModule(ModuleMgr, PP);
569 if (!TopM)
570 return false;
571
572 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
573 // contains the union of their flags.
574 return checkDiagnosticMappings(*Diags, ExistingDiags, TopM->IsSystem,
575 Complain);
576}
577
578/// Collect the macro definitions provided by the given preprocessor
579/// options.
580static void
581collectMacroDefinitions(const PreprocessorOptions &PPOpts,
582 MacroDefinitionsMap &Macros,
583 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
584 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
585 StringRef Macro = PPOpts.Macros[I].first;
586 bool IsUndef = PPOpts.Macros[I].second;
587
588 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
589 StringRef MacroName = MacroPair.first;
590 StringRef MacroBody = MacroPair.second;
591
592 // For an #undef'd macro, we only care about the name.
593 if (IsUndef) {
594 if (MacroNames && !Macros.count(MacroName))
595 MacroNames->push_back(MacroName);
596
597 Macros[MacroName] = std::make_pair("", true);
598 continue;
599 }
600
601 // For a #define'd macro, figure out the actual definition.
602 if (MacroName.size() == Macro.size())
603 MacroBody = "1";
604 else {
605 // Note: GCC drops anything following an end-of-line character.
606 StringRef::size_type End = MacroBody.find_first_of("\n\r");
607 MacroBody = MacroBody.substr(0, End);
608 }
609
610 if (MacroNames && !Macros.count(MacroName))
611 MacroNames->push_back(MacroName);
612 Macros[MacroName] = std::make_pair(MacroBody, false);
613 }
614}
615
616/// Check the preprocessor options deserialized from the control block
617/// against the preprocessor options in an existing preprocessor.
618///
619/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620/// \param Validate If true, validate preprocessor options. If false, allow
621/// macros defined by \p ExistingPPOpts to override those defined by
622/// \p PPOpts in SuggestedPredefines.
623static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
624 const PreprocessorOptions &ExistingPPOpts,
625 DiagnosticsEngine *Diags,
626 FileManager &FileMgr,
627 std::string &SuggestedPredefines,
628 const LangOptions &LangOpts,
629 bool Validate = true) {
630 // Check macro definitions.
631 MacroDefinitionsMap ASTFileMacros;
632 collectMacroDefinitions(PPOpts, ASTFileMacros);
633 MacroDefinitionsMap ExistingMacros;
634 SmallVector<StringRef, 4> ExistingMacroNames;
635 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
636
637 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
638 // Dig out the macro definition in the existing preprocessor options.
639 StringRef MacroName = ExistingMacroNames[I];
640 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
641
642 // Check whether we know anything about this macro name or not.
643 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/>>::iterator Known =
644 ASTFileMacros.find(MacroName);
645 if (!Validate || Known == ASTFileMacros.end()) {
646 // FIXME: Check whether this identifier was referenced anywhere in the
647 // AST file. If so, we should reject the AST file. Unfortunately, this
648 // information isn't in the control block. What shall we do about it?
649
650 if (Existing.second) {
651 SuggestedPredefines += "#undef ";
652 SuggestedPredefines += MacroName.str();
653 SuggestedPredefines += '\n';
654 } else {
655 SuggestedPredefines += "#define ";
656 SuggestedPredefines += MacroName.str();
657 SuggestedPredefines += ' ';
658 SuggestedPredefines += Existing.first.str();
659 SuggestedPredefines += '\n';
660 }
661 continue;
662 }
663
664 // If the macro was defined in one but undef'd in the other, we have a
665 // conflict.
666 if (Existing.second != Known->second.second) {
667 if (Diags) {
668 Diags->Report(diag::err_pch_macro_def_undef)
669 << MacroName << Known->second.second;
670 }
671 return true;
672 }
673
674 // If the macro was #undef'd in both, or if the macro bodies are identical,
675 // it's fine.
676 if (Existing.second || Existing.first == Known->second.first)
677 continue;
678
679 // The macro bodies differ; complain.
680 if (Diags) {
681 Diags->Report(diag::err_pch_macro_def_conflict)
682 << MacroName << Known->second.first << Existing.first;
683 }
684 return true;
685 }
686
687 // Check whether we're using predefines.
688 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines && Validate) {
689 if (Diags) {
690 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
691 }
692 return true;
693 }
694
695 // Detailed record is important since it is used for the module cache hash.
696 if (LangOpts.Modules &&
697 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord && Validate) {
698 if (Diags) {
699 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
700 }
701 return true;
702 }
703
704 // Compute the #include and #include_macros lines we need.
705 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
706 StringRef File = ExistingPPOpts.Includes[I];
707
708 if (!ExistingPPOpts.ImplicitPCHInclude.empty() &&
709 !ExistingPPOpts.PCHThroughHeader.empty()) {
710 // In case the through header is an include, we must add all the includes
711 // to the predefines so the start point can be determined.
712 SuggestedPredefines += "#include \"";
713 SuggestedPredefines += File;
714 SuggestedPredefines += "\"\n";
715 continue;
716 }
717
718 if (File == ExistingPPOpts.ImplicitPCHInclude)
719 continue;
720
721 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
722 != PPOpts.Includes.end())
723 continue;
724
725 SuggestedPredefines += "#include \"";
726 SuggestedPredefines += File;
727 SuggestedPredefines += "\"\n";
728 }
729
730 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
731 StringRef File = ExistingPPOpts.MacroIncludes[I];
732 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
733 File)
734 != PPOpts.MacroIncludes.end())
735 continue;
736
737 SuggestedPredefines += "#__include_macros \"";
738 SuggestedPredefines += File;
739 SuggestedPredefines += "\"\n##\n";
740 }
741
742 return false;
743}
744
745bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
746 bool Complain,
747 std::string &SuggestedPredefines) {
748 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
749
750 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
751 Complain? &Reader.Diags : nullptr,
752 PP.getFileManager(),
753 SuggestedPredefines,
754 PP.getLangOpts());
755}
756
757bool SimpleASTReaderListener::ReadPreprocessorOptions(
758 const PreprocessorOptions &PPOpts,
759 bool Complain,
760 std::string &SuggestedPredefines) {
761 return checkPreprocessorOptions(PPOpts,
762 PP.getPreprocessorOpts(),
763 nullptr,
764 PP.getFileManager(),
765 SuggestedPredefines,
766 PP.getLangOpts(),
767 false);
768}
769
770/// Check the header search options deserialized from the control block
771/// against the header search options in an existing preprocessor.
772///
773/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
774static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
775 StringRef SpecificModuleCachePath,
776 StringRef ExistingModuleCachePath,
777 DiagnosticsEngine *Diags,
778 const LangOptions &LangOpts) {
779 if (LangOpts.Modules) {
780 if (SpecificModuleCachePath != ExistingModuleCachePath) {
781 if (Diags)
782 Diags->Report(diag::err_pch_modulecache_mismatch)
783 << SpecificModuleCachePath << ExistingModuleCachePath;
784 return true;
785 }
786 }
787
788 return false;
789}
790
791bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
792 StringRef SpecificModuleCachePath,
793 bool Complain) {
794 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
795 PP.getHeaderSearchInfo().getModuleCachePath(),
796 Complain ? &Reader.Diags : nullptr,
797 PP.getLangOpts());
798}
799
800void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
801 PP.setCounterValue(Value);
802}
803
804//===----------------------------------------------------------------------===//
805// AST reader implementation
806//===----------------------------------------------------------------------===//
807
808void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
809 bool TakeOwnership) {
810 DeserializationListener = Listener;
811 OwnsDeserializationListener = TakeOwnership;
812}
813
814unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
815 return serialization::ComputeHash(Sel);
816}
817
818std::pair<unsigned, unsigned>
819ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
820 using namespace llvm::support;
821
822 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
823 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
824 return std::make_pair(KeyLen, DataLen);
825}
826
827ASTSelectorLookupTrait::internal_key_type
828ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
829 using namespace llvm::support;
830
831 SelectorTable &SelTable = Reader.getContext().Selectors;
832 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
833 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
834 F, endian::readNext<uint32_t, little, unaligned>(d));
835 if (N == 0)
836 return SelTable.getNullarySelector(FirstII);
837 else if (N == 1)
838 return SelTable.getUnarySelector(FirstII);
839
840 SmallVector<IdentifierInfo *, 16> Args;
841 Args.push_back(FirstII);
842 for (unsigned I = 1; I != N; ++I)
843 Args.push_back(Reader.getLocalIdentifier(
844 F, endian::readNext<uint32_t, little, unaligned>(d)));
845
846 return SelTable.getSelector(N, Args.data());
847}
848
849ASTSelectorLookupTrait::data_type
850ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
851 unsigned DataLen) {
852 using namespace llvm::support;
853
854 data_type Result;
855
856 Result.ID = Reader.getGlobalSelectorID(
857 F, endian::readNext<uint32_t, little, unaligned>(d));
858 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
859 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
860 Result.InstanceBits = FullInstanceBits & 0x3;
861 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
862 Result.FactoryBits = FullFactoryBits & 0x3;
863 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
864 unsigned NumInstanceMethods = FullInstanceBits >> 3;
865 unsigned NumFactoryMethods = FullFactoryBits >> 3;
866
867 // Load instance methods
868 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
869 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
870 F, endian::readNext<uint32_t, little, unaligned>(d)))
871 Result.Instance.push_back(Method);
872 }
873
874 // Load factory methods
875 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
876 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
877 F, endian::readNext<uint32_t, little, unaligned>(d)))
878 Result.Factory.push_back(Method);
879 }
880
881 return Result;
882}
883
884unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
885 return llvm::djbHash(a);
886}
887
888std::pair<unsigned, unsigned>
889ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
890 using namespace llvm::support;
891
892 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
893 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
894 return std::make_pair(KeyLen, DataLen);
895}
896
897ASTIdentifierLookupTraitBase::internal_key_type
898ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
899 assert(n >= 2 && d[n-1] == '\0')((n >= 2 && d[n-1] == '\0') ? static_cast<void>
(0) : __assert_fail ("n >= 2 && d[n-1] == '\\0'",
"/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 899, __PRETTY_FUNCTION__))
;
900 return StringRef((const char*) d, n-1);
901}
902
903/// Whether the given identifier is "interesting".
904static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
905 bool IsModule) {
906 return II.hadMacroDefinition() ||
907 II.isPoisoned() ||
908 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
909 II.hasRevertedTokenIDToIdentifier() ||
910 (!(IsModule && Reader.getPreprocessor().getLangOpts().CPlusPlus) &&
911 II.getFETokenInfo());
912}
913
914static bool readBit(unsigned &Bits) {
915 bool Value = Bits & 0x1;
916 Bits >>= 1;
917 return Value;
918}
919
920IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
921 using namespace llvm::support;
922
923 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
924 return Reader.getGlobalIdentifierID(F, RawID >> 1);
925}
926
927static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
928 if (!II.isFromAST()) {
929 II.setIsFromAST();
930 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
931 if (isInterestingIdentifier(Reader, II, IsModule))
932 II.setChangedSinceDeserialization();
933 }
934}
935
936IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
937 const unsigned char* d,
938 unsigned DataLen) {
939 using namespace llvm::support;
940
941 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
942 bool IsInteresting = RawID & 0x01;
943
944 // Wipe out the "is interesting" bit.
945 RawID = RawID >> 1;
946
947 // Build the IdentifierInfo and link the identifier ID with it.
948 IdentifierInfo *II = KnownII;
949 if (!II) {
950 II = &Reader.getIdentifierTable().getOwn(k);
951 KnownII = II;
952 }
953 markIdentifierFromAST(Reader, *II);
954 Reader.markIdentifierUpToDate(II);
955
956 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
957 if (!IsInteresting) {
958 // For uninteresting identifiers, there's nothing else to do. Just notify
959 // the reader that we've finished loading this identifier.
960 Reader.SetIdentifierInfo(ID, II);
961 return II;
962 }
963
964 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
965 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
966 bool CPlusPlusOperatorKeyword = readBit(Bits);
967 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
968 bool HasRevertedBuiltin = readBit(Bits);
969 bool Poisoned = readBit(Bits);
970 bool ExtensionToken = readBit(Bits);
971 bool HadMacroDefinition = readBit(Bits);
972
973 assert(Bits == 0 && "Extra bits in the identifier?")((Bits == 0 && "Extra bits in the identifier?") ? static_cast
<void> (0) : __assert_fail ("Bits == 0 && \"Extra bits in the identifier?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 973, __PRETTY_FUNCTION__))
;
974 DataLen -= 8;
975
976 // Set or check the various bits in the IdentifierInfo structure.
977 // Token IDs are read-only.
978 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
979 II->revertTokenIDToIdentifier();
980 if (!F.isModule())
981 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
982 else if (HasRevertedBuiltin && II->getBuiltinID()) {
983 II->revertBuiltin();
984 assert((II->hasRevertedBuiltin() ||(((II->hasRevertedBuiltin() || II->getObjCOrBuiltinID()
== ObjCOrBuiltinID) && "Incorrect ObjC keyword or builtin ID"
) ? static_cast<void> (0) : __assert_fail ("(II->hasRevertedBuiltin() || II->getObjCOrBuiltinID() == ObjCOrBuiltinID) && \"Incorrect ObjC keyword or builtin ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 986, __PRETTY_FUNCTION__))
985 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&(((II->hasRevertedBuiltin() || II->getObjCOrBuiltinID()
== ObjCOrBuiltinID) && "Incorrect ObjC keyword or builtin ID"
) ? static_cast<void> (0) : __assert_fail ("(II->hasRevertedBuiltin() || II->getObjCOrBuiltinID() == ObjCOrBuiltinID) && \"Incorrect ObjC keyword or builtin ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 986, __PRETTY_FUNCTION__))
986 "Incorrect ObjC keyword or builtin ID")(((II->hasRevertedBuiltin() || II->getObjCOrBuiltinID()
== ObjCOrBuiltinID) && "Incorrect ObjC keyword or builtin ID"
) ? static_cast<void> (0) : __assert_fail ("(II->hasRevertedBuiltin() || II->getObjCOrBuiltinID() == ObjCOrBuiltinID) && \"Incorrect ObjC keyword or builtin ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 986, __PRETTY_FUNCTION__))
;
987 }
988 assert(II->isExtensionToken() == ExtensionToken &&((II->isExtensionToken() == ExtensionToken && "Incorrect extension token flag"
) ? static_cast<void> (0) : __assert_fail ("II->isExtensionToken() == ExtensionToken && \"Incorrect extension token flag\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 989, __PRETTY_FUNCTION__))
989 "Incorrect extension token flag")((II->isExtensionToken() == ExtensionToken && "Incorrect extension token flag"
) ? static_cast<void> (0) : __assert_fail ("II->isExtensionToken() == ExtensionToken && \"Incorrect extension token flag\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 989, __PRETTY_FUNCTION__))
;
990 (void)ExtensionToken;
991 if (Poisoned)
992 II->setIsPoisoned(true);
993 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&((II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword
&& "Incorrect C++ operator keyword flag") ? static_cast
<void> (0) : __assert_fail ("II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && \"Incorrect C++ operator keyword flag\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 994, __PRETTY_FUNCTION__))
994 "Incorrect C++ operator keyword flag")((II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword
&& "Incorrect C++ operator keyword flag") ? static_cast
<void> (0) : __assert_fail ("II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && \"Incorrect C++ operator keyword flag\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 994, __PRETTY_FUNCTION__))
;
995 (void)CPlusPlusOperatorKeyword;
996
997 // If this identifier is a macro, deserialize the macro
998 // definition.
999 if (HadMacroDefinition) {
1000 uint32_t MacroDirectivesOffset =
1001 endian::readNext<uint32_t, little, unaligned>(d);
1002 DataLen -= 4;
1003
1004 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
1005 }
1006
1007 Reader.SetIdentifierInfo(ID, II);
1008
1009 // Read all of the declarations visible at global scope with this
1010 // name.
1011 if (DataLen > 0) {
1012 SmallVector<uint32_t, 4> DeclIDs;
1013 for (; DataLen > 0; DataLen -= 4)
1014 DeclIDs.push_back(Reader.getGlobalDeclID(
1015 F, endian::readNext<uint32_t, little, unaligned>(d)));
1016 Reader.SetGloballyVisibleDecls(II, DeclIDs);
1017 }
1018
1019 return II;
1020}
1021
1022DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
1023 : Kind(Name.getNameKind()) {
1024 switch (Kind) {
1025 case DeclarationName::Identifier:
1026 Data = (uint64_t)Name.getAsIdentifierInfo();
1027 break;
1028 case DeclarationName::ObjCZeroArgSelector:
1029 case DeclarationName::ObjCOneArgSelector:
1030 case DeclarationName::ObjCMultiArgSelector:
1031 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
1032 break;
1033 case DeclarationName::CXXOperatorName:
1034 Data = Name.getCXXOverloadedOperator();
1035 break;
1036 case DeclarationName::CXXLiteralOperatorName:
1037 Data = (uint64_t)Name.getCXXLiteralIdentifier();
1038 break;
1039 case DeclarationName::CXXDeductionGuideName:
1040 Data = (uint64_t)Name.getCXXDeductionGuideTemplate()
1041 ->getDeclName().getAsIdentifierInfo();
1042 break;
1043 case DeclarationName::CXXConstructorName:
1044 case DeclarationName::CXXDestructorName:
1045 case DeclarationName::CXXConversionFunctionName:
1046 case DeclarationName::CXXUsingDirective:
1047 Data = 0;
1048 break;
1049 }
1050}
1051
1052unsigned DeclarationNameKey::getHash() const {
1053 llvm::FoldingSetNodeID ID;
1054 ID.AddInteger(Kind);
1055
1056 switch (Kind) {
1057 case DeclarationName::Identifier:
1058 case DeclarationName::CXXLiteralOperatorName:
1059 case DeclarationName::CXXDeductionGuideName:
1060 ID.AddString(((IdentifierInfo*)Data)->getName());
1061 break;
1062 case DeclarationName::ObjCZeroArgSelector:
1063 case DeclarationName::ObjCOneArgSelector:
1064 case DeclarationName::ObjCMultiArgSelector:
1065 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
1066 break;
1067 case DeclarationName::CXXOperatorName:
1068 ID.AddInteger((OverloadedOperatorKind)Data);
1069 break;
1070 case DeclarationName::CXXConstructorName:
1071 case DeclarationName::CXXDestructorName:
1072 case DeclarationName::CXXConversionFunctionName:
1073 case DeclarationName::CXXUsingDirective:
1074 break;
1075 }
1076
1077 return ID.ComputeHash();
1078}
1079
1080ModuleFile *
1081ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
1082 using namespace llvm::support;
1083
1084 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
1085 return Reader.getLocalModuleFile(F, ModuleFileID);
1086}
1087
1088std::pair<unsigned, unsigned>
1089ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
1090 using namespace llvm::support;
1091
1092 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
1093 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
1094 return std::make_pair(KeyLen, DataLen);
1095}
1096
1097ASTDeclContextNameLookupTrait::internal_key_type
1098ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
1099 using namespace llvm::support;
1100
1101 auto Kind = (DeclarationName::NameKind)*d++;
1102 uint64_t Data;
1103 switch (Kind) {
1104 case DeclarationName::Identifier:
1105 case DeclarationName::CXXLiteralOperatorName:
1106 case DeclarationName::CXXDeductionGuideName:
1107 Data = (uint64_t)Reader.getLocalIdentifier(
1108 F, endian::readNext<uint32_t, little, unaligned>(d));
1109 break;
1110 case DeclarationName::ObjCZeroArgSelector:
1111 case DeclarationName::ObjCOneArgSelector:
1112 case DeclarationName::ObjCMultiArgSelector:
1113 Data =
1114 (uint64_t)Reader.getLocalSelector(
1115 F, endian::readNext<uint32_t, little, unaligned>(
1116 d)).getAsOpaquePtr();
1117 break;
1118 case DeclarationName::CXXOperatorName:
1119 Data = *d++; // OverloadedOperatorKind
1120 break;
1121 case DeclarationName::CXXConstructorName:
1122 case DeclarationName::CXXDestructorName:
1123 case DeclarationName::CXXConversionFunctionName:
1124 case DeclarationName::CXXUsingDirective:
1125 Data = 0;
1126 break;
1127 }
1128
1129 return DeclarationNameKey(Kind, Data);
1130}
1131
1132void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
1133 const unsigned char *d,
1134 unsigned DataLen,
1135 data_type_builder &Val) {
1136 using namespace llvm::support;
1137
1138 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
1139 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
1140 Val.insert(Reader.getGlobalDeclID(F, LocalID));
1141 }
1142}
1143
1144bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
1145 BitstreamCursor &Cursor,
1146 uint64_t Offset,
1147 DeclContext *DC) {
1148 assert(Offset != 0)((Offset != 0) ? static_cast<void> (0) : __assert_fail (
"Offset != 0", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1148, __PRETTY_FUNCTION__))
;
1149
1150 SavedStreamPosition SavedPosition(Cursor);
1151 Cursor.JumpToBit(Offset);
1152
1153 RecordData Record;
1154 StringRef Blob;
1155 unsigned Code = Cursor.ReadCode();
1156 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1157 if (RecCode != DECL_CONTEXT_LEXICAL) {
1158 Error("Expected lexical block");
1159 return true;
1160 }
1161
1162 assert(!isa<TranslationUnitDecl>(DC) &&((!isa<TranslationUnitDecl>(DC) && "expected a TU_UPDATE_LEXICAL record for TU"
) ? static_cast<void> (0) : __assert_fail ("!isa<TranslationUnitDecl>(DC) && \"expected a TU_UPDATE_LEXICAL record for TU\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1163, __PRETTY_FUNCTION__))
1163 "expected a TU_UPDATE_LEXICAL record for TU")((!isa<TranslationUnitDecl>(DC) && "expected a TU_UPDATE_LEXICAL record for TU"
) ? static_cast<void> (0) : __assert_fail ("!isa<TranslationUnitDecl>(DC) && \"expected a TU_UPDATE_LEXICAL record for TU\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1163, __PRETTY_FUNCTION__))
;
1164 // If we are handling a C++ class template instantiation, we can see multiple
1165 // lexical updates for the same record. It's important that we select only one
1166 // of them, so that field numbering works properly. Just pick the first one we
1167 // see.
1168 auto &Lex = LexicalDecls[DC];
1169 if (!Lex.first) {
1170 Lex = std::make_pair(
1171 &M, llvm::makeArrayRef(
1172 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1173 Blob.data()),
1174 Blob.size() / 4));
1175 }
1176 DC->setHasExternalLexicalStorage(true);
1177 return false;
1178}
1179
1180bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1181 BitstreamCursor &Cursor,
1182 uint64_t Offset,
1183 DeclID ID) {
1184 assert(Offset != 0)((Offset != 0) ? static_cast<void> (0) : __assert_fail (
"Offset != 0", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1184, __PRETTY_FUNCTION__))
;
1185
1186 SavedStreamPosition SavedPosition(Cursor);
1187 Cursor.JumpToBit(Offset);
1188
1189 RecordData Record;
1190 StringRef Blob;
1191 unsigned Code = Cursor.ReadCode();
1192 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1193 if (RecCode != DECL_CONTEXT_VISIBLE) {
1194 Error("Expected visible lookup table block");
1195 return true;
1196 }
1197
1198 // We can't safely determine the primary context yet, so delay attaching the
1199 // lookup table until we're done with recursive deserialization.
1200 auto *Data = (const unsigned char*)Blob.data();
1201 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1202 return false;
1203}
1204
1205void ASTReader::Error(StringRef Msg) const {
1206 Error(diag::err_fe_pch_malformed, Msg);
1207 if (PP.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1208 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1209 Diag(diag::note_module_cache_path)
1210 << PP.getHeaderSearchInfo().getModuleCachePath();
1211 }
1212}
1213
1214void ASTReader::Error(unsigned DiagID,
1215 StringRef Arg1, StringRef Arg2) const {
1216 if (Diags.isDiagnosticInFlight())
1217 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1218 else
1219 Diag(DiagID) << Arg1 << Arg2;
1220}
1221
1222//===----------------------------------------------------------------------===//
1223// Source Manager Deserialization
1224//===----------------------------------------------------------------------===//
1225
1226/// Read the line table in the source manager block.
1227/// \returns true if there was an error.
1228bool ASTReader::ParseLineTable(ModuleFile &F,
1229 const RecordData &Record) {
1230 unsigned Idx = 0;
1231 LineTableInfo &LineTable = SourceMgr.getLineTable();
1232
1233 // Parse the file names
1234 std::map<int, int> FileIDs;
1235 FileIDs[-1] = -1; // For unspecified filenames.
1236 for (unsigned I = 0; Record[Idx]; ++I) {
1237 // Extract the file name
1238 auto Filename = ReadPath(F, Record, Idx);
1239 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1240 }
1241 ++Idx;
1242
1243 // Parse the line entries
1244 std::vector<LineEntry> Entries;
1245 while (Idx < Record.size()) {
1246 int FID = Record[Idx++];
1247 assert(FID >= 0 && "Serialized line entries for non-local file.")((FID >= 0 && "Serialized line entries for non-local file."
) ? static_cast<void> (0) : __assert_fail ("FID >= 0 && \"Serialized line entries for non-local file.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1247, __PRETTY_FUNCTION__))
;
1248 // Remap FileID from 1-based old view.
1249 FID += F.SLocEntryBaseID - 1;
1250
1251 // Extract the line entries
1252 unsigned NumEntries = Record[Idx++];
1253 assert(NumEntries && "no line entries for file ID")((NumEntries && "no line entries for file ID") ? static_cast
<void> (0) : __assert_fail ("NumEntries && \"no line entries for file ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1253, __PRETTY_FUNCTION__))
;
1254 Entries.clear();
1255 Entries.reserve(NumEntries);
1256 for (unsigned I = 0; I != NumEntries; ++I) {
1257 unsigned FileOffset = Record[Idx++];
1258 unsigned LineNo = Record[Idx++];
1259 int FilenameID = FileIDs[Record[Idx++]];
1260 SrcMgr::CharacteristicKind FileKind
1261 = (SrcMgr::CharacteristicKind)Record[Idx++];
1262 unsigned IncludeOffset = Record[Idx++];
1263 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1264 FileKind, IncludeOffset));
1265 }
1266 LineTable.AddEntry(FileID::get(FID), Entries);
1267 }
1268
1269 return false;
1270}
1271
1272/// Read a source manager block
1273bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1274 using namespace SrcMgr;
1275
1276 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1277
1278 // Set the source-location entry cursor to the current position in
1279 // the stream. This cursor will be used to read the contents of the
1280 // source manager block initially, and then lazily read
1281 // source-location entries as needed.
1282 SLocEntryCursor = F.Stream;
1283
1284 // The stream itself is going to skip over the source manager block.
1285 if (F.Stream.SkipBlock()) {
1286 Error("malformed block record in AST file");
1287 return true;
1288 }
1289
1290 // Enter the source manager block.
1291 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1292 Error("malformed source manager block record in AST file");
1293 return true;
1294 }
1295
1296 RecordData Record;
1297 while (true) {
1298 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1299
1300 switch (E.Kind) {
1301 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1302 case llvm::BitstreamEntry::Error:
1303 Error("malformed block record in AST file");
1304 return true;
1305 case llvm::BitstreamEntry::EndBlock:
1306 return false;
1307 case llvm::BitstreamEntry::Record:
1308 // The interesting case.
1309 break;
1310 }
1311
1312 // Read a record.
1313 Record.clear();
1314 StringRef Blob;
1315 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1316 default: // Default behavior: ignore.
1317 break;
1318
1319 case SM_SLOC_FILE_ENTRY:
1320 case SM_SLOC_BUFFER_ENTRY:
1321 case SM_SLOC_EXPANSION_ENTRY:
1322 // Once we hit one of the source location entries, we're done.
1323 return false;
1324 }
1325 }
1326}
1327
1328/// If a header file is not found at the path that we expect it to be
1329/// and the PCH file was moved from its original location, try to resolve the
1330/// file by assuming that header+PCH were moved together and the header is in
1331/// the same place relative to the PCH.
1332static std::string
1333resolveFileRelativeToOriginalDir(const std::string &Filename,
1334 const std::string &OriginalDir,
1335 const std::string &CurrDir) {
1336 assert(OriginalDir != CurrDir &&((OriginalDir != CurrDir && "No point trying to resolve the file if the PCH dir didn't change"
) ? static_cast<void> (0) : __assert_fail ("OriginalDir != CurrDir && \"No point trying to resolve the file if the PCH dir didn't change\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1337, __PRETTY_FUNCTION__))
1337 "No point trying to resolve the file if the PCH dir didn't change")((OriginalDir != CurrDir && "No point trying to resolve the file if the PCH dir didn't change"
) ? static_cast<void> (0) : __assert_fail ("OriginalDir != CurrDir && \"No point trying to resolve the file if the PCH dir didn't change\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1337, __PRETTY_FUNCTION__))
;
1338
1339 using namespace llvm::sys;
1340
1341 SmallString<128> filePath(Filename);
1342 fs::make_absolute(filePath);
1343 assert(path::is_absolute(OriginalDir))((path::is_absolute(OriginalDir)) ? static_cast<void> (
0) : __assert_fail ("path::is_absolute(OriginalDir)", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1343, __PRETTY_FUNCTION__))
;
1344 SmallString<128> currPCHPath(CurrDir);
1345
1346 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1347 fileDirE = path::end(path::parent_path(filePath));
1348 path::const_iterator origDirI = path::begin(OriginalDir),
1349 origDirE = path::end(OriginalDir);
1350 // Skip the common path components from filePath and OriginalDir.
1351 while (fileDirI != fileDirE && origDirI != origDirE &&
1352 *fileDirI == *origDirI) {
1353 ++fileDirI;
1354 ++origDirI;
1355 }
1356 for (; origDirI != origDirE; ++origDirI)
1357 path::append(currPCHPath, "..");
1358 path::append(currPCHPath, fileDirI, fileDirE);
1359 path::append(currPCHPath, path::filename(Filename));
1360 return currPCHPath.str();
1361}
1362
1363bool ASTReader::ReadSLocEntry(int ID) {
1364 if (ID == 0)
1365 return false;
1366
1367 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1368 Error("source location entry ID out-of-range for AST file");
1369 return true;
1370 }
1371
1372 // Local helper to read the (possibly-compressed) buffer data following the
1373 // entry record.
1374 auto ReadBuffer = [this](
1375 BitstreamCursor &SLocEntryCursor,
1376 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1377 RecordData Record;
1378 StringRef Blob;
1379 unsigned Code = SLocEntryCursor.ReadCode();
1380 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1381
1382 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1383 if (!llvm::zlib::isAvailable()) {
1384 Error("zlib is not available");
1385 return nullptr;
1386 }
1387 SmallString<0> Uncompressed;
1388 if (llvm::Error E =
1389 llvm::zlib::uncompress(Blob, Uncompressed, Record[0])) {
1390 Error("could not decompress embedded file contents: " +
1391 llvm::toString(std::move(E)));
1392 return nullptr;
1393 }
1394 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1395 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1396 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1397 } else {
1398 Error("AST record has invalid code");
1399 return nullptr;
1400 }
1401 };
1402
1403 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1404 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1405 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1406 unsigned BaseOffset = F->SLocEntryBaseOffset;
1407
1408 ++NumSLocEntriesRead;
1409 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1410 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1411 Error("incorrectly-formatted source location entry in AST file");
1412 return true;
1413 }
1414
1415 RecordData Record;
1416 StringRef Blob;
1417 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1418 default:
1419 Error("incorrectly-formatted source location entry in AST file");
1420 return true;
1421
1422 case SM_SLOC_FILE_ENTRY: {
1423 // We will detect whether a file changed and return 'Failure' for it, but
1424 // we will also try to fail gracefully by setting up the SLocEntry.
1425 unsigned InputID = Record[4];
1426 InputFile IF = getInputFile(*F, InputID);
1427 const FileEntry *File = IF.getFile();
1428 bool OverriddenBuffer = IF.isOverridden();
1429
1430 // Note that we only check if a File was returned. If it was out-of-date
1431 // we have complained but we will continue creating a FileID to recover
1432 // gracefully.
1433 if (!File)
1434 return true;
1435
1436 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1437 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1438 // This is the module's main file.
1439 IncludeLoc = getImportLocation(F);
1440 }
1441 SrcMgr::CharacteristicKind
1442 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1443 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1444 ID, BaseOffset + Record[0]);
1445 SrcMgr::FileInfo &FileInfo =
1446 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1447 FileInfo.NumCreatedFIDs = Record[5];
1448 if (Record[3])
1449 FileInfo.setHasLineDirectives();
1450
1451 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1452 unsigned NumFileDecls = Record[7];
1453 if (NumFileDecls && ContextObj) {
1454 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?")((F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?"
) ? static_cast<void> (0) : __assert_fail ("F->FileSortedDecls && \"FILE_SORTED_DECLS not encountered yet ?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1454, __PRETTY_FUNCTION__))
;
1455 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1456 NumFileDecls));
1457 }
1458
1459 const SrcMgr::ContentCache *ContentCache
1460 = SourceMgr.getOrCreateContentCache(File, isSystem(FileCharacter));
1461 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1462 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1463 !ContentCache->getRawBuffer()) {
1464 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1465 if (!Buffer)
1466 return true;
1467 SourceMgr.overrideFileContents(File, std::move(Buffer));
1468 }
1469
1470 break;
1471 }
1472
1473 case SM_SLOC_BUFFER_ENTRY: {
1474 const char *Name = Blob.data();
1475 unsigned Offset = Record[0];
1476 SrcMgr::CharacteristicKind
1477 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1478 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1479 if (IncludeLoc.isInvalid() && F->isModule()) {
1480 IncludeLoc = getImportLocation(F);
1481 }
1482
1483 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1484 if (!Buffer)
1485 return true;
1486 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1487 BaseOffset + Offset, IncludeLoc);
1488 break;
1489 }
1490
1491 case SM_SLOC_EXPANSION_ENTRY: {
1492 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1493 SourceMgr.createExpansionLoc(SpellingLoc,
1494 ReadSourceLocation(*F, Record[2]),
1495 ReadSourceLocation(*F, Record[3]),
1496 Record[5],
1497 Record[4],
1498 ID,
1499 BaseOffset + Record[0]);
1500 break;
1501 }
1502 }
1503
1504 return false;
1505}
1506
1507std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1508 if (ID == 0)
1509 return std::make_pair(SourceLocation(), "");
1510
1511 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1512 Error("source location entry ID out-of-range for AST file");
1513 return std::make_pair(SourceLocation(), "");
1514 }
1515
1516 // Find which module file this entry lands in.
1517 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1518 if (!M->isModule())
1519 return std::make_pair(SourceLocation(), "");
1520
1521 // FIXME: Can we map this down to a particular submodule? That would be
1522 // ideal.
1523 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1524}
1525
1526/// Find the location where the module F is imported.
1527SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1528 if (F->ImportLoc.isValid())
1529 return F->ImportLoc;
1530
1531 // Otherwise we have a PCH. It's considered to be "imported" at the first
1532 // location of its includer.
1533 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1534 // Main file is the importer.
1535 assert(SourceMgr.getMainFileID().isValid() && "missing main file")((SourceMgr.getMainFileID().isValid() && "missing main file"
) ? static_cast<void> (0) : __assert_fail ("SourceMgr.getMainFileID().isValid() && \"missing main file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1535, __PRETTY_FUNCTION__))
;
1536 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1537 }
1538 return F->ImportedBy[0]->FirstLoc;
1539}
1540
1541/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1542/// specified cursor. Read the abbreviations that are at the top of the block
1543/// and then leave the cursor pointing into the block.
1544bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1545 if (Cursor.EnterSubBlock(BlockID))
1546 return true;
1547
1548 while (true) {
1549 uint64_t Offset = Cursor.GetCurrentBitNo();
1550 unsigned Code = Cursor.ReadCode();
1551
1552 // We expect all abbrevs to be at the start of the block.
1553 if (Code != llvm::bitc::DEFINE_ABBREV) {
1554 Cursor.JumpToBit(Offset);
1555 return false;
1556 }
1557 Cursor.ReadAbbrevRecord();
1558 }
1559}
1560
1561Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1562 unsigned &Idx) {
1563 Token Tok;
1564 Tok.startToken();
1565 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1566 Tok.setLength(Record[Idx++]);
1567 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1568 Tok.setIdentifierInfo(II);
1569 Tok.setKind((tok::TokenKind)Record[Idx++]);
1570 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1571 return Tok;
1572}
1573
1574MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1575 BitstreamCursor &Stream = F.MacroCursor;
1576
1577 // Keep track of where we are in the stream, then jump back there
1578 // after reading this macro.
1579 SavedStreamPosition SavedPosition(Stream);
1580
1581 Stream.JumpToBit(Offset);
1582 RecordData Record;
1583 SmallVector<IdentifierInfo*, 16> MacroParams;
1584 MacroInfo *Macro = nullptr;
1585
1586 while (true) {
1587 // Advance to the next record, but if we get to the end of the block, don't
1588 // pop it (removing all the abbreviations from the cursor) since we want to
1589 // be able to reseek within the block and read entries.
1590 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1591 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1592
1593 switch (Entry.Kind) {
1594 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1595 case llvm::BitstreamEntry::Error:
1596 Error("malformed block record in AST file");
1597 return Macro;
1598 case llvm::BitstreamEntry::EndBlock:
1599 return Macro;
1600 case llvm::BitstreamEntry::Record:
1601 // The interesting case.
1602 break;
1603 }
1604
1605 // Read a record.
1606 Record.clear();
1607 PreprocessorRecordTypes RecType =
1608 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1609 switch (RecType) {
1610 case PP_MODULE_MACRO:
1611 case PP_MACRO_DIRECTIVE_HISTORY:
1612 return Macro;
1613
1614 case PP_MACRO_OBJECT_LIKE:
1615 case PP_MACRO_FUNCTION_LIKE: {
1616 // If we already have a macro, that means that we've hit the end
1617 // of the definition of the macro we were looking for. We're
1618 // done.
1619 if (Macro)
1620 return Macro;
1621
1622 unsigned NextIndex = 1; // Skip identifier ID.
1623 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1624 MacroInfo *MI = PP.AllocateMacroInfo(Loc);
1625 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1626 MI->setIsUsed(Record[NextIndex++]);
1627 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1628
1629 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1630 // Decode function-like macro info.
1631 bool isC99VarArgs = Record[NextIndex++];
1632 bool isGNUVarArgs = Record[NextIndex++];
1633 bool hasCommaPasting = Record[NextIndex++];
1634 MacroParams.clear();
1635 unsigned NumArgs = Record[NextIndex++];
1636 for (unsigned i = 0; i != NumArgs; ++i)
1637 MacroParams.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1638
1639 // Install function-like macro info.
1640 MI->setIsFunctionLike();
1641 if (isC99VarArgs) MI->setIsC99Varargs();
1642 if (isGNUVarArgs) MI->setIsGNUVarargs();
1643 if (hasCommaPasting) MI->setHasCommaPasting();
1644 MI->setParameterList(MacroParams, PP.getPreprocessorAllocator());
1645 }
1646
1647 // Remember that we saw this macro last so that we add the tokens that
1648 // form its body to it.
1649 Macro = MI;
1650
1651 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1652 Record[NextIndex]) {
1653 // We have a macro definition. Register the association
1654 PreprocessedEntityID
1655 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1656 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1657 PreprocessingRecord::PPEntityID PPID =
1658 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1659 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1660 PPRec.getPreprocessedEntity(PPID));
1661 if (PPDef)
1662 PPRec.RegisterMacroDefinition(Macro, PPDef);
1663 }
1664
1665 ++NumMacrosRead;
1666 break;
1667 }
1668
1669 case PP_TOKEN: {
1670 // If we see a TOKEN before a PP_MACRO_*, then the file is
1671 // erroneous, just pretend we didn't see this.
1672 if (!Macro) break;
1673
1674 unsigned Idx = 0;
1675 Token Tok = ReadToken(F, Record, Idx);
1676 Macro->AddTokenToBody(Tok);
1677 break;
1678 }
1679 }
1680 }
1681}
1682
1683PreprocessedEntityID
1684ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M,
1685 unsigned LocalID) const {
1686 if (!M.ModuleOffsetMap.empty())
1687 ReadModuleOffsetMap(M);
1688
1689 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1690 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1691 assert(I != M.PreprocessedEntityRemap.end()((I != M.PreprocessedEntityRemap.end() && "Invalid index into preprocessed entity index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.PreprocessedEntityRemap.end() && \"Invalid index into preprocessed entity index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1692, __PRETTY_FUNCTION__))
1692 && "Invalid index into preprocessed entity index remap")((I != M.PreprocessedEntityRemap.end() && "Invalid index into preprocessed entity index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.PreprocessedEntityRemap.end() && \"Invalid index into preprocessed entity index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1692, __PRETTY_FUNCTION__))
;
1693
1694 return LocalID + I->second;
1695}
1696
1697unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1698 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1699}
1700
1701HeaderFileInfoTrait::internal_key_type
1702HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1703 internal_key_type ikey = {FE->getSize(),
1704 M.HasTimestamps ? FE->getModificationTime() : 0,
1705 FE->getName(), /*Imported*/ false};
1706 return ikey;
1707}
1708
1709bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1710 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1711 return false;
1712
1713 if (llvm::sys::path::is_absolute(a.Filename) && a.Filename == b.Filename)
1714 return true;
1715
1716 // Determine whether the actual files are equivalent.
1717 FileManager &FileMgr = Reader.getFileManager();
1718 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1719 if (!Key.Imported)
1720 return FileMgr.getFile(Key.Filename);
1721
1722 std::string Resolved = Key.Filename;
1723 Reader.ResolveImportedPath(M, Resolved);
1724 return FileMgr.getFile(Resolved);
1725 };
1726
1727 const FileEntry *FEA = GetFile(a);
1728 const FileEntry *FEB = GetFile(b);
1729 return FEA && FEA == FEB;
1730}
1731
1732std::pair<unsigned, unsigned>
1733HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1734 using namespace llvm::support;
1735
1736 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1737 unsigned DataLen = (unsigned) *d++;
1738 return std::make_pair(KeyLen, DataLen);
1739}
1740
1741HeaderFileInfoTrait::internal_key_type
1742HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1743 using namespace llvm::support;
1744
1745 internal_key_type ikey;
1746 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1747 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1748 ikey.Filename = (const char *)d;
1749 ikey.Imported = true;
1750 return ikey;
1751}
1752
1753HeaderFileInfoTrait::data_type
1754HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1755 unsigned DataLen) {
1756 using namespace llvm::support;
1757
1758 const unsigned char *End = d + DataLen;
1759 HeaderFileInfo HFI;
1760 unsigned Flags = *d++;
1761 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1762 HFI.isImport |= (Flags >> 5) & 0x01;
1763 HFI.isPragmaOnce |= (Flags >> 4) & 0x01;
1764 HFI.DirInfo = (Flags >> 1) & 0x07;
1765 HFI.IndexHeaderMapHeader = Flags & 0x01;
1766 // FIXME: Find a better way to handle this. Maybe just store a
1767 // "has been included" flag?
1768 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1769 HFI.NumIncludes);
1770 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1771 M, endian::readNext<uint32_t, little, unaligned>(d));
1772 if (unsigned FrameworkOffset =
1773 endian::readNext<uint32_t, little, unaligned>(d)) {
1774 // The framework offset is 1 greater than the actual offset,
1775 // since 0 is used as an indicator for "no framework name".
1776 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1777 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1778 }
1779
1780 assert((End - d) % 4 == 0 &&(((End - d) % 4 == 0 && "Wrong data length in HeaderFileInfo deserialization"
) ? static_cast<void> (0) : __assert_fail ("(End - d) % 4 == 0 && \"Wrong data length in HeaderFileInfo deserialization\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1781, __PRETTY_FUNCTION__))
1781 "Wrong data length in HeaderFileInfo deserialization")(((End - d) % 4 == 0 && "Wrong data length in HeaderFileInfo deserialization"
) ? static_cast<void> (0) : __assert_fail ("(End - d) % 4 == 0 && \"Wrong data length in HeaderFileInfo deserialization\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1781, __PRETTY_FUNCTION__))
;
1782 while (d != End) {
1783 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1784 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1785 LocalSMID >>= 2;
1786
1787 // This header is part of a module. Associate it with the module to enable
1788 // implicit module import.
1789 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1790 Module *Mod = Reader.getSubmodule(GlobalSMID);
1791 FileManager &FileMgr = Reader.getFileManager();
1792 ModuleMap &ModMap =
1793 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1794
1795 std::string Filename = key.Filename;
1796 if (key.Imported)
1797 Reader.ResolveImportedPath(M, Filename);
1798 // FIXME: This is not always the right filename-as-written, but we're not
1799 // going to use this information to rebuild the module, so it doesn't make
1800 // a lot of difference.
1801 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1802 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1803 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1804 }
1805
1806 // This HeaderFileInfo was externally loaded.
1807 HFI.External = true;
1808 HFI.IsValid = true;
1809 return HFI;
1810}
1811
1812void ASTReader::addPendingMacro(IdentifierInfo *II,
1813 ModuleFile *M,
1814 uint64_t MacroDirectivesOffset) {
1815 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard")((NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"
) ? static_cast<void> (0) : __assert_fail ("NumCurrentElementsDeserializing > 0 &&\"Missing deserialization guard\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 1815, __PRETTY_FUNCTION__))
;
1816 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1817}
1818
1819void ASTReader::ReadDefinedMacros() {
1820 // Note that we are loading defined macros.
1821 Deserializing Macros(this);
1822
1823 for (ModuleFile &I : llvm::reverse(ModuleMgr)) {
1824 BitstreamCursor &MacroCursor = I.MacroCursor;
1825
1826 // If there was no preprocessor block, skip this file.
1827 if (MacroCursor.getBitcodeBytes().empty())
1828 continue;
1829
1830 BitstreamCursor Cursor = MacroCursor;
1831 Cursor.JumpToBit(I.MacroStartOffset);
1832
1833 RecordData Record;
1834 while (true) {
1835 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1836
1837 switch (E.Kind) {
1838 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1839 case llvm::BitstreamEntry::Error:
1840 Error("malformed block record in AST file");
1841 return;
1842 case llvm::BitstreamEntry::EndBlock:
1843 goto NextCursor;
1844
1845 case llvm::BitstreamEntry::Record:
1846 Record.clear();
1847 switch (Cursor.readRecord(E.ID, Record)) {
1848 default: // Default behavior: ignore.
1849 break;
1850
1851 case PP_MACRO_OBJECT_LIKE:
1852 case PP_MACRO_FUNCTION_LIKE: {
1853 IdentifierInfo *II = getLocalIdentifier(I, Record[0]);
1854 if (II->isOutOfDate())
1855 updateOutOfDateIdentifier(*II);
1856 break;
1857 }
1858
1859 case PP_TOKEN:
1860 // Ignore tokens.
1861 break;
1862 }
1863 break;
1864 }
1865 }
1866 NextCursor: ;
1867 }
1868}
1869
1870namespace {
1871
1872 /// Visitor class used to look up identifirs in an AST file.
1873 class IdentifierLookupVisitor {
1874 StringRef Name;
1875 unsigned NameHash;
1876 unsigned PriorGeneration;
1877 unsigned &NumIdentifierLookups;
1878 unsigned &NumIdentifierLookupHits;
1879 IdentifierInfo *Found = nullptr;
1880
1881 public:
1882 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1883 unsigned &NumIdentifierLookups,
1884 unsigned &NumIdentifierLookupHits)
1885 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1886 PriorGeneration(PriorGeneration),
1887 NumIdentifierLookups(NumIdentifierLookups),
1888 NumIdentifierLookupHits(NumIdentifierLookupHits) {}
1889
1890 bool operator()(ModuleFile &M) {
1891 // If we've already searched this module file, skip it now.
1892 if (M.Generation <= PriorGeneration)
1893 return true;
1894
1895 ASTIdentifierLookupTable *IdTable
1896 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1897 if (!IdTable)
1898 return false;
1899
1900 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1901 Found);
1902 ++NumIdentifierLookups;
1903 ASTIdentifierLookupTable::iterator Pos =
1904 IdTable->find_hashed(Name, NameHash, &Trait);
1905 if (Pos == IdTable->end())
1906 return false;
1907
1908 // Dereferencing the iterator has the effect of building the
1909 // IdentifierInfo node and populating it with the various
1910 // declarations it needs.
1911 ++NumIdentifierLookupHits;
1912 Found = *Pos;
1913 return true;
1914 }
1915
1916 // Retrieve the identifier info found within the module
1917 // files.
1918 IdentifierInfo *getIdentifierInfo() const { return Found; }
1919 };
1920
1921} // namespace
1922
1923void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1924 // Note that we are loading an identifier.
1925 Deserializing AnIdentifier(this);
1926
1927 unsigned PriorGeneration = 0;
1928 if (getContext().getLangOpts().Modules)
1929 PriorGeneration = IdentifierGeneration[&II];
1930
1931 // If there is a global index, look there first to determine which modules
1932 // provably do not have any results for this identifier.
1933 GlobalModuleIndex::HitSet Hits;
1934 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1935 if (!loadGlobalIndex()) {
1936 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1937 HitsPtr = &Hits;
1938 }
1939 }
1940
1941 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1942 NumIdentifierLookups,
1943 NumIdentifierLookupHits);
1944 ModuleMgr.visit(Visitor, HitsPtr);
1945 markIdentifierUpToDate(&II);
1946}
1947
1948void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1949 if (!II)
1950 return;
1951
1952 II->setOutOfDate(false);
1953
1954 // Update the generation for this identifier.
1955 if (getContext().getLangOpts().Modules)
1956 IdentifierGeneration[II] = getGeneration();
1957}
1958
1959void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1960 const PendingMacroInfo &PMInfo) {
1961 ModuleFile &M = *PMInfo.M;
1962
1963 BitstreamCursor &Cursor = M.MacroCursor;
1964 SavedStreamPosition SavedPosition(Cursor);
1965 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1966
1967 struct ModuleMacroRecord {
1968 SubmoduleID SubModID;
1969 MacroInfo *MI;
1970 SmallVector<SubmoduleID, 8> Overrides;
1971 };
1972 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
1973
1974 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1975 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1976 // macro histroy.
1977 RecordData Record;
1978 while (true) {
1979 llvm::BitstreamEntry Entry =
1980 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1981 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1982 Error("malformed block record in AST file");
1983 return;
1984 }
1985
1986 Record.clear();
1987 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1988 case PP_MACRO_DIRECTIVE_HISTORY:
1989 break;
1990
1991 case PP_MODULE_MACRO: {
1992 ModuleMacros.push_back(ModuleMacroRecord());
1993 auto &Info = ModuleMacros.back();
1994 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1995 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1996 for (int I = 2, N = Record.size(); I != N; ++I)
1997 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1998 continue;
1999 }
2000
2001 default:
2002 Error("malformed block record in AST file");
2003 return;
2004 }
2005
2006 // We found the macro directive history; that's the last record
2007 // for this macro.
2008 break;
2009 }
2010
2011 // Module macros are listed in reverse dependency order.
2012 {
2013 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
2014 llvm::SmallVector<ModuleMacro*, 8> Overrides;
2015 for (auto &MMR : ModuleMacros) {
2016 Overrides.clear();
2017 for (unsigned ModID : MMR.Overrides) {
2018 Module *Mod = getSubmodule(ModID);
2019 auto *Macro = PP.getModuleMacro(Mod, II);
2020 assert(Macro && "missing definition for overridden macro")((Macro && "missing definition for overridden macro")
? static_cast<void> (0) : __assert_fail ("Macro && \"missing definition for overridden macro\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2020, __PRETTY_FUNCTION__))
;
2021 Overrides.push_back(Macro);
2022 }
2023
2024 bool Inserted = false;
2025 Module *Owner = getSubmodule(MMR.SubModID);
2026 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
2027 }
2028 }
2029
2030 // Don't read the directive history for a module; we don't have anywhere
2031 // to put it.
2032 if (M.isModule())
2033 return;
2034
2035 // Deserialize the macro directives history in reverse source-order.
2036 MacroDirective *Latest = nullptr, *Earliest = nullptr;
2037 unsigned Idx = 0, N = Record.size();
2038 while (Idx < N) {
2039 MacroDirective *MD = nullptr;
2040 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
2041 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
2042 switch (K) {
2043 case MacroDirective::MD_Define: {
2044 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
2045 MD = PP.AllocateDefMacroDirective(MI, Loc);
2046 break;
2047 }
2048 case MacroDirective::MD_Undefine:
2049 MD = PP.AllocateUndefMacroDirective(Loc);
2050 break;
2051 case MacroDirective::MD_Visibility:
2052 bool isPublic = Record[Idx++];
2053 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
2054 break;
2055 }
2056
2057 if (!Latest)
2058 Latest = MD;
2059 if (Earliest)
2060 Earliest->setPrevious(MD);
2061 Earliest = MD;
2062 }
2063
2064 if (Latest)
2065 PP.setLoadedMacroDirective(II, Earliest, Latest);
2066}
2067
2068ASTReader::InputFileInfo
2069ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
2070 // Go find this input file.
2071 BitstreamCursor &Cursor = F.InputFilesCursor;
2072 SavedStreamPosition SavedPosition(Cursor);
2073 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2074
2075 unsigned Code = Cursor.ReadCode();
4
Calling 'BitstreamCursor::ReadCode'
2076 RecordData Record;
2077 StringRef Blob;
2078
2079 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
2080 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&((static_cast<InputFileRecordTypes>(Result) == INPUT_FILE
&& "invalid record type for input file") ? static_cast
<void> (0) : __assert_fail ("static_cast<InputFileRecordTypes>(Result) == INPUT_FILE && \"invalid record type for input file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2081, __PRETTY_FUNCTION__))
2081 "invalid record type for input file")((static_cast<InputFileRecordTypes>(Result) == INPUT_FILE
&& "invalid record type for input file") ? static_cast
<void> (0) : __assert_fail ("static_cast<InputFileRecordTypes>(Result) == INPUT_FILE && \"invalid record type for input file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2081, __PRETTY_FUNCTION__))
;
2082 (void)Result;
2083
2084 assert(Record[0] == ID && "Bogus stored ID or offset")((Record[0] == ID && "Bogus stored ID or offset") ? static_cast
<void> (0) : __assert_fail ("Record[0] == ID && \"Bogus stored ID or offset\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2084, __PRETTY_FUNCTION__))
;
2085 InputFileInfo R;
2086 R.StoredSize = static_cast<off_t>(Record[1]);
2087 R.StoredTime = static_cast<time_t>(Record[2]);
2088 R.Overridden = static_cast<bool>(Record[3]);
2089 R.Transient = static_cast<bool>(Record[4]);
2090 R.TopLevelModuleMap = static_cast<bool>(Record[5]);
2091 R.Filename = Blob;
2092 ResolveImportedPath(F, R.Filename);
2093 return R;
2094}
2095
2096static unsigned moduleKindForDiagnostic(ModuleKind Kind);
2097InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
2098 // If this ID is bogus, just return an empty input file.
2099 if (ID == 0 || ID > F.InputFilesLoaded.size())
2100 return InputFile();
2101
2102 // If we've already loaded this input file, return it.
2103 if (F.InputFilesLoaded[ID-1].getFile())
2104 return F.InputFilesLoaded[ID-1];
2105
2106 if (F.InputFilesLoaded[ID-1].isNotFound())
2107 return InputFile();
2108
2109 // Go find this input file.
2110 BitstreamCursor &Cursor = F.InputFilesCursor;
2111 SavedStreamPosition SavedPosition(Cursor);
2112 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
2113
2114 InputFileInfo FI = readInputFileInfo(F, ID);
2115 off_t StoredSize = FI.StoredSize;
2116 time_t StoredTime = FI.StoredTime;
2117 bool Overridden = FI.Overridden;
2118 bool Transient = FI.Transient;
2119 StringRef Filename = FI.Filename;
2120
2121 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
2122 // If we didn't find the file, resolve it relative to the
2123 // original directory from which this AST file was created.
2124 if (File == nullptr && !F.OriginalDir.empty() && !F.BaseDirectory.empty() &&
2125 F.OriginalDir != F.BaseDirectory) {
2126 std::string Resolved = resolveFileRelativeToOriginalDir(
2127 Filename, F.OriginalDir, F.BaseDirectory);
2128 if (!Resolved.empty())
2129 File = FileMgr.getFile(Resolved);
2130 }
2131
2132 // For an overridden file, create a virtual file with the stored
2133 // size/timestamp.
2134 if ((Overridden || Transient) && File == nullptr)
2135 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
2136
2137 if (File == nullptr) {
2138 if (Complain) {
2139 std::string ErrorStr = "could not find file '";
2140 ErrorStr += Filename;
2141 ErrorStr += "' referenced by AST file '";
2142 ErrorStr += F.FileName;
2143 ErrorStr += "'";
2144 Error(ErrorStr);
2145 }
2146 // Record that we didn't find the file.
2147 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
2148 return InputFile();
2149 }
2150
2151 // Check if there was a request to override the contents of the file
2152 // that was part of the precompiled header. Overriding such a file
2153 // can lead to problems when lexing using the source locations from the
2154 // PCH.
2155 SourceManager &SM = getSourceManager();
2156 // FIXME: Reject if the overrides are different.
2157 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
2158 if (Complain)
2159 Error(diag::err_fe_pch_file_overridden, Filename);
2160 // After emitting the diagnostic, recover by disabling the override so
2161 // that the original file will be used.
2162 //
2163 // FIXME: This recovery is just as broken as the original state; there may
2164 // be another precompiled module that's using the overridden contents, or
2165 // we might be half way through parsing it. Instead, we should treat the
2166 // overridden contents as belonging to a separate FileEntry.
2167 SM.disableFileContentsOverride(File);
2168 // The FileEntry is a virtual file entry with the size of the contents
2169 // that would override the original contents. Set it to the original's
2170 // size/time.
2171 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2172 StoredSize, StoredTime);
2173 }
2174
2175 bool IsOutOfDate = false;
2176
2177 // For an overridden file, there is nothing to validate.
2178 if (!Overridden && //
2179 (StoredSize != File->getSize() ||
2180 (StoredTime && StoredTime != File->getModificationTime() &&
2181 !DisableValidation)
2182 )) {
2183 if (Complain) {
2184 // Build a list of the PCH imports that got us here (in reverse).
2185 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2186 while (!ImportStack.back()->ImportedBy.empty())
2187 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2188
2189 // The top-level PCH is stale.
2190 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2191 unsigned DiagnosticKind = moduleKindForDiagnostic(ImportStack.back()->Kind);
2192 if (DiagnosticKind == 0)
2193 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2194 else if (DiagnosticKind == 1)
2195 Error(diag::err_fe_module_file_modified, Filename, TopLevelPCHName);
2196 else
2197 Error(diag::err_fe_ast_file_modified, Filename, TopLevelPCHName);
2198
2199 // Print the import stack.
2200 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2201 Diag(diag::note_pch_required_by)
2202 << Filename << ImportStack[0]->FileName;
2203 for (unsigned I = 1; I < ImportStack.size(); ++I)
2204 Diag(diag::note_pch_required_by)
2205 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2206 }
2207
2208 if (!Diags.isDiagnosticInFlight())
2209 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2210 }
2211
2212 IsOutOfDate = true;
2213 }
2214 // FIXME: If the file is overridden and we've already opened it,
2215 // issue an error (or split it into a separate FileEntry).
2216
2217 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2218
2219 // Note that we've loaded this input file.
2220 F.InputFilesLoaded[ID-1] = IF;
2221 return IF;
2222}
2223
2224/// If we are loading a relocatable PCH or module file, and the filename
2225/// is not an absolute path, add the system or module root to the beginning of
2226/// the file name.
2227void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2228 // Resolve relative to the base directory, if we have one.
2229 if (!M.BaseDirectory.empty())
2230 return ResolveImportedPath(Filename, M.BaseDirectory);
2231}
2232
2233void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2234 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2235 return;
2236
2237 SmallString<128> Buffer;
2238 llvm::sys::path::append(Buffer, Prefix, Filename);
2239 Filename.assign(Buffer.begin(), Buffer.end());
2240}
2241
2242static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2243 switch (ARR) {
2244 case ASTReader::Failure: return true;
2245 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2246 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2247 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2248 case ASTReader::ConfigurationMismatch:
2249 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2250 case ASTReader::HadErrors: return true;
2251 case ASTReader::Success: return false;
2252 }
2253
2254 llvm_unreachable("unknown ASTReadResult")::llvm::llvm_unreachable_internal("unknown ASTReadResult", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2254)
;
2255}
2256
2257ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2258 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2259 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2260 std::string &SuggestedPredefines) {
2261 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2262 return Failure;
2263
2264 // Read all of the records in the options block.
2265 RecordData Record;
2266 ASTReadResult Result = Success;
2267 while (true) {
2268 llvm::BitstreamEntry Entry = Stream.advance();
2269
2270 switch (Entry.Kind) {
2271 case llvm::BitstreamEntry::Error:
2272 case llvm::BitstreamEntry::SubBlock:
2273 return Failure;
2274
2275 case llvm::BitstreamEntry::EndBlock:
2276 return Result;
2277
2278 case llvm::BitstreamEntry::Record:
2279 // The interesting case.
2280 break;
2281 }
2282
2283 // Read and process a record.
2284 Record.clear();
2285 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2286 case LANGUAGE_OPTIONS: {
2287 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2288 if (ParseLanguageOptions(Record, Complain, Listener,
2289 AllowCompatibleConfigurationMismatch))
2290 Result = ConfigurationMismatch;
2291 break;
2292 }
2293
2294 case TARGET_OPTIONS: {
2295 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2296 if (ParseTargetOptions(Record, Complain, Listener,
2297 AllowCompatibleConfigurationMismatch))
2298 Result = ConfigurationMismatch;
2299 break;
2300 }
2301
2302 case FILE_SYSTEM_OPTIONS: {
2303 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2304 if (!AllowCompatibleConfigurationMismatch &&
2305 ParseFileSystemOptions(Record, Complain, Listener))
2306 Result = ConfigurationMismatch;
2307 break;
2308 }
2309
2310 case HEADER_SEARCH_OPTIONS: {
2311 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2312 if (!AllowCompatibleConfigurationMismatch &&
2313 ParseHeaderSearchOptions(Record, Complain, Listener))
2314 Result = ConfigurationMismatch;
2315 break;
2316 }
2317
2318 case PREPROCESSOR_OPTIONS:
2319 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2320 if (!AllowCompatibleConfigurationMismatch &&
2321 ParsePreprocessorOptions(Record, Complain, Listener,
2322 SuggestedPredefines))
2323 Result = ConfigurationMismatch;
2324 break;
2325 }
2326 }
2327}
2328
2329ASTReader::ASTReadResult
2330ASTReader::ReadControlBlock(ModuleFile &F,
2331 SmallVectorImpl<ImportedModule> &Loaded,
2332 const ModuleFile *ImportedBy,
2333 unsigned ClientLoadCapabilities) {
2334 BitstreamCursor &Stream = F.Stream;
2335 ASTReadResult Result = Success;
2336
2337 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2338 Error("malformed block record in AST file");
2339 return Failure;
2340 }
2341
2342 // Lambda to read the unhashed control block the first time it's called.
2343 //
2344 // For PCM files, the unhashed control block cannot be read until after the
2345 // MODULE_NAME record. However, PCH files have no MODULE_NAME, and yet still
2346 // need to look ahead before reading the IMPORTS record. For consistency,
2347 // this block is always read somehow (see BitstreamEntry::EndBlock).
2348 bool HasReadUnhashedControlBlock = false;
2349 auto readUnhashedControlBlockOnce = [&]() {
2350 if (!HasReadUnhashedControlBlock) {
2351 HasReadUnhashedControlBlock = true;
2352 if (ASTReadResult Result =
2353 readUnhashedControlBlock(F, ImportedBy, ClientLoadCapabilities))
2354 return Result;
2355 }
2356 return Success;
2357 };
2358
2359 // Read all of the records and blocks in the control block.
2360 RecordData Record;
2361 unsigned NumInputs = 0;
2362 unsigned NumUserInputs = 0;
2363 StringRef BaseDirectoryAsWritten;
2364 while (true) {
2365 llvm::BitstreamEntry Entry = Stream.advance();
2366
2367 switch (Entry.Kind) {
2368 case llvm::BitstreamEntry::Error:
2369 Error("malformed block record in AST file");
2370 return Failure;
2371 case llvm::BitstreamEntry::EndBlock: {
2372 // Validate the module before returning. This call catches an AST with
2373 // no module name and no imports.
2374 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2375 return Result;
2376
2377 // Validate input files.
2378 const HeaderSearchOptions &HSOpts =
2379 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2380
2381 // All user input files reside at the index range [0, NumUserInputs), and
2382 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2383 // loaded module files, ignore missing inputs.
2384 if (!DisableValidation && F.Kind != MK_ExplicitModule &&
2385 F.Kind != MK_PrebuiltModule) {
2386 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2387
2388 // If we are reading a module, we will create a verification timestamp,
2389 // so we verify all input files. Otherwise, verify only user input
2390 // files.
2391
2392 unsigned N = NumUserInputs;
2393 if (ValidateSystemInputs ||
2394 (HSOpts.ModulesValidateOncePerBuildSession &&
2395 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2396 F.Kind == MK_ImplicitModule))
2397 N = NumInputs;
2398
2399 for (unsigned I = 0; I < N; ++I) {
2400 InputFile IF = getInputFile(F, I+1, Complain);
2401 if (!IF.getFile() || IF.isOutOfDate())
2402 return OutOfDate;
2403 }
2404 }
2405
2406 if (Listener)
2407 Listener->visitModuleFile(F.FileName, F.Kind);
2408
2409 if (Listener && Listener->needsInputFileVisitation()) {
2410 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2411 : NumUserInputs;
2412 for (unsigned I = 0; I < N; ++I) {
2413 bool IsSystem = I >= NumUserInputs;
2414 InputFileInfo FI = readInputFileInfo(F, I+1);
2415 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2416 F.Kind == MK_ExplicitModule ||
2417 F.Kind == MK_PrebuiltModule);
2418 }
2419 }
2420
2421 return Result;
2422 }
2423
2424 case llvm::BitstreamEntry::SubBlock:
2425 switch (Entry.ID) {
2426 case INPUT_FILES_BLOCK_ID:
2427 F.InputFilesCursor = Stream;
2428 if (Stream.SkipBlock() || // Skip with the main cursor
2429 // Read the abbreviations
2430 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2431 Error("malformed block record in AST file");
2432 return Failure;
2433 }
2434 continue;
2435
2436 case OPTIONS_BLOCK_ID:
2437 // If we're reading the first module for this group, check its options
2438 // are compatible with ours. For modules it imports, no further checking
2439 // is required, because we checked them when we built it.
2440 if (Listener && !ImportedBy) {
2441 // Should we allow the configuration of the module file to differ from
2442 // the configuration of the current translation unit in a compatible
2443 // way?
2444 //
2445 // FIXME: Allow this for files explicitly specified with -include-pch.
2446 bool AllowCompatibleConfigurationMismatch =
2447 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
2448
2449 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2450 AllowCompatibleConfigurationMismatch,
2451 *Listener, SuggestedPredefines);
2452 if (Result == Failure) {
2453 Error("malformed block record in AST file");
2454 return Result;
2455 }
2456
2457 if (DisableValidation ||
2458 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2459 Result = Success;
2460
2461 // If we can't load the module, exit early since we likely
2462 // will rebuild the module anyway. The stream may be in the
2463 // middle of a block.
2464 if (Result != Success)
2465 return Result;
2466 } else if (Stream.SkipBlock()) {
2467 Error("malformed block record in AST file");
2468 return Failure;
2469 }
2470 continue;
2471
2472 default:
2473 if (Stream.SkipBlock()) {
2474 Error("malformed block record in AST file");
2475 return Failure;
2476 }
2477 continue;
2478 }
2479
2480 case llvm::BitstreamEntry::Record:
2481 // The interesting case.
2482 break;
2483 }
2484
2485 // Read and process a record.
2486 Record.clear();
2487 StringRef Blob;
2488 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2489 case METADATA: {
2490 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2491 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2492 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2493 : diag::err_pch_version_too_new);
2494 return VersionMismatch;
2495 }
2496
2497 bool hasErrors = Record[7];
2498 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2499 Diag(diag::err_pch_with_compiler_errors);
2500 return HadErrors;
2501 }
2502 if (hasErrors) {
2503 Diags.ErrorOccurred = true;
2504 Diags.UncompilableErrorOccurred = true;
2505 Diags.UnrecoverableErrorOccurred = true;
2506 }
2507
2508 F.RelocatablePCH = Record[4];
2509 // Relative paths in a relocatable PCH are relative to our sysroot.
2510 if (F.RelocatablePCH)
2511 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2512
2513 F.HasTimestamps = Record[5];
2514
2515 F.PCHHasObjectFile = Record[6];
2516
2517 const std::string &CurBranch = getClangFullRepositoryVersion();
2518 StringRef ASTBranch = Blob;
2519 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2520 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2521 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2522 return VersionMismatch;
2523 }
2524 break;
2525 }
2526
2527 case IMPORTS: {
2528 // Validate the AST before processing any imports (otherwise, untangling
2529 // them can be error-prone and expensive). A module will have a name and
2530 // will already have been validated, but this catches the PCH case.
2531 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2532 return Result;
2533
2534 // Load each of the imported PCH files.
2535 unsigned Idx = 0, N = Record.size();
2536 while (Idx < N) {
2537 // Read information about the AST file.
2538 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2539 // The import location will be the local one for now; we will adjust
2540 // all import locations of module imports after the global source
2541 // location info are setup, in ReadAST.
2542 SourceLocation ImportLoc =
2543 ReadUntranslatedSourceLocation(Record[Idx++]);
2544 off_t StoredSize = (off_t)Record[Idx++];
2545 time_t StoredModTime = (time_t)Record[Idx++];
2546 ASTFileSignature StoredSignature = {
2547 {{(uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2548 (uint32_t)Record[Idx++], (uint32_t)Record[Idx++],
2549 (uint32_t)Record[Idx++]}}};
2550
2551 std::string ImportedName = ReadString(Record, Idx);
2552 std::string ImportedFile;
2553
2554 // For prebuilt and explicit modules first consult the file map for
2555 // an override. Note that here we don't search prebuilt module
2556 // directories, only the explicit name to file mappings. Also, we will
2557 // still verify the size/signature making sure it is essentially the
2558 // same file but perhaps in a different location.
2559 if (ImportedKind == MK_PrebuiltModule || ImportedKind == MK_ExplicitModule)
2560 ImportedFile = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(
2561 ImportedName, /*FileMapOnly*/ true);
2562
2563 if (ImportedFile.empty())
2564 // Use BaseDirectoryAsWritten to ensure we use the same path in the
2565 // ModuleCache as when writing.
2566 ImportedFile = ReadPath(BaseDirectoryAsWritten, Record, Idx);
2567 else
2568 SkipPath(Record, Idx);
2569
2570 // If our client can't cope with us being out of date, we can't cope with
2571 // our dependency being missing.
2572 unsigned Capabilities = ClientLoadCapabilities;
2573 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2574 Capabilities &= ~ARR_Missing;
2575
2576 // Load the AST file.
2577 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2578 Loaded, StoredSize, StoredModTime,
2579 StoredSignature, Capabilities);
2580
2581 // If we diagnosed a problem, produce a backtrace.
2582 if (isDiagnosedResult(Result, Capabilities))
2583 Diag(diag::note_module_file_imported_by)
2584 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2585
2586 switch (Result) {
2587 case Failure: return Failure;
2588 // If we have to ignore the dependency, we'll have to ignore this too.
2589 case Missing:
2590 case OutOfDate: return OutOfDate;
2591 case VersionMismatch: return VersionMismatch;
2592 case ConfigurationMismatch: return ConfigurationMismatch;
2593 case HadErrors: return HadErrors;
2594 case Success: break;
2595 }
2596 }
2597 break;
2598 }
2599
2600 case ORIGINAL_FILE:
2601 F.OriginalSourceFileID = FileID::get(Record[0]);
2602 F.ActualOriginalSourceFileName = Blob;
2603 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2604 ResolveImportedPath(F, F.OriginalSourceFileName);
2605 break;
2606
2607 case ORIGINAL_FILE_ID:
2608 F.OriginalSourceFileID = FileID::get(Record[0]);
2609 break;
2610
2611 case ORIGINAL_PCH_DIR:
2612 F.OriginalDir = Blob;
2613 break;
2614
2615 case MODULE_NAME:
2616 F.ModuleName = Blob;
2617 Diag(diag::remark_module_import)
2618 << F.ModuleName << F.FileName << (ImportedBy ? true : false)
2619 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
2620 if (Listener)
2621 Listener->ReadModuleName(F.ModuleName);
2622
2623 // Validate the AST as soon as we have a name so we can exit early on
2624 // failure.
2625 if (ASTReadResult Result = readUnhashedControlBlockOnce())
2626 return Result;
2627
2628 break;
2629
2630 case MODULE_DIRECTORY: {
2631 // Save the BaseDirectory as written in the PCM for computing the module
2632 // filename for the ModuleCache.
2633 BaseDirectoryAsWritten = Blob;
2634 assert(!F.ModuleName.empty() &&((!F.ModuleName.empty() && "MODULE_DIRECTORY found before MODULE_NAME"
) ? static_cast<void> (0) : __assert_fail ("!F.ModuleName.empty() && \"MODULE_DIRECTORY found before MODULE_NAME\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2635, __PRETTY_FUNCTION__))
2635 "MODULE_DIRECTORY found before MODULE_NAME")((!F.ModuleName.empty() && "MODULE_DIRECTORY found before MODULE_NAME"
) ? static_cast<void> (0) : __assert_fail ("!F.ModuleName.empty() && \"MODULE_DIRECTORY found before MODULE_NAME\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 2635, __PRETTY_FUNCTION__))
;
2636 // If we've already loaded a module map file covering this module, we may
2637 // have a better path for it (relative to the current build).
2638 Module *M = PP.getHeaderSearchInfo().lookupModule(
2639 F.ModuleName, /*AllowSearch*/ true,
2640 /*AllowExtraModuleMapSearch*/ true);
2641 if (M && M->Directory) {
2642 // If we're implicitly loading a module, the base directory can't
2643 // change between the build and use.
2644 // Don't emit module relocation error if we have -fno-validate-pch
2645 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
2646 F.Kind != MK_ExplicitModule && F.Kind != MK_PrebuiltModule) {
2647 const DirectoryEntry *BuildDir =
2648 PP.getFileManager().getDirectory(Blob);
2649 if (!BuildDir || BuildDir != M->Directory) {
2650 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2651 Diag(diag::err_imported_module_relocated)
2652 << F.ModuleName << Blob << M->Directory->getName();
2653 return OutOfDate;
2654 }
2655 }
2656 F.BaseDirectory = M->Directory->getName();
2657 } else {
2658 F.BaseDirectory = Blob;
2659 }
2660 break;
2661 }
2662
2663 case MODULE_MAP_FILE:
2664 if (ASTReadResult Result =
2665 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2666 return Result;
2667 break;
2668
2669 case INPUT_FILE_OFFSETS:
2670 NumInputs = Record[0];
2671 NumUserInputs = Record[1];
2672 F.InputFileOffsets =
2673 (const llvm::support::unaligned_uint64_t *)Blob.data();
2674 F.InputFilesLoaded.resize(NumInputs);
2675 F.NumUserInputFiles = NumUserInputs;
2676 break;
2677 }
2678 }
2679}
2680
2681ASTReader::ASTReadResult
2682ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2683 BitstreamCursor &Stream = F.Stream;
2684
2685 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2686 Error("malformed block record in AST file");
2687 return Failure;
2688 }
2689
2690 // Read all of the records and blocks for the AST file.
2691 RecordData Record;
2692 while (true) {
2693 llvm::BitstreamEntry Entry = Stream.advance();
2694
2695 switch (Entry.Kind) {
2696 case llvm::BitstreamEntry::Error:
2697 Error("error at end of module block in AST file");
2698 return Failure;
2699 case llvm::BitstreamEntry::EndBlock:
2700 // Outside of C++, we do not store a lookup map for the translation unit.
2701 // Instead, mark it as needing a lookup map to be built if this module
2702 // contains any declarations lexically within it (which it always does!).
2703 // This usually has no cost, since we very rarely need the lookup map for
2704 // the translation unit outside C++.
2705 if (ASTContext *Ctx = ContextObj) {
2706 DeclContext *DC = Ctx->getTranslationUnitDecl();
2707 if (DC->hasExternalLexicalStorage() && !Ctx->getLangOpts().CPlusPlus)
2708 DC->setMustBuildLookupTable();
2709 }
2710
2711 return Success;
2712 case llvm::BitstreamEntry::SubBlock:
2713 switch (Entry.ID) {
2714 case DECLTYPES_BLOCK_ID:
2715 // We lazily load the decls block, but we want to set up the
2716 // DeclsCursor cursor to point into it. Clone our current bitcode
2717 // cursor to it, enter the block and read the abbrevs in that block.
2718 // With the main cursor, we just skip over it.
2719 F.DeclsCursor = Stream;
2720 if (Stream.SkipBlock() || // Skip with the main cursor.
2721 // Read the abbrevs.
2722 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2723 Error("malformed block record in AST file");
2724 return Failure;
2725 }
2726 break;
2727
2728 case PREPROCESSOR_BLOCK_ID:
2729 F.MacroCursor = Stream;
2730 if (!PP.getExternalSource())
2731 PP.setExternalSource(this);
2732
2733 if (Stream.SkipBlock() ||
2734 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2735 Error("malformed block record in AST file");
2736 return Failure;
2737 }
2738 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2739 break;
2740
2741 case PREPROCESSOR_DETAIL_BLOCK_ID:
2742 F.PreprocessorDetailCursor = Stream;
2743 if (Stream.SkipBlock() ||
2744 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2745 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2746 Error("malformed preprocessor detail record in AST file");
2747 return Failure;
2748 }
2749 F.PreprocessorDetailStartOffset
2750 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2751
2752 if (!PP.getPreprocessingRecord())
2753 PP.createPreprocessingRecord();
2754 if (!PP.getPreprocessingRecord()->getExternalSource())
2755 PP.getPreprocessingRecord()->SetExternalSource(*this);
2756 break;
2757
2758 case SOURCE_MANAGER_BLOCK_ID:
2759 if (ReadSourceManagerBlock(F))
2760 return Failure;
2761 break;
2762
2763 case SUBMODULE_BLOCK_ID:
2764 if (ASTReadResult Result =
2765 ReadSubmoduleBlock(F, ClientLoadCapabilities))
2766 return Result;
2767 break;
2768
2769 case COMMENTS_BLOCK_ID: {
2770 BitstreamCursor C = Stream;
2771 if (Stream.SkipBlock() ||
2772 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2773 Error("malformed comments block in AST file");
2774 return Failure;
2775 }
2776 CommentsCursors.push_back(std::make_pair(C, &F));
2777 break;
2778 }
2779
2780 default:
2781 if (Stream.SkipBlock()) {
2782 Error("malformed block record in AST file");
2783 return Failure;
2784 }
2785 break;
2786 }
2787 continue;
2788
2789 case llvm::BitstreamEntry::Record:
2790 // The interesting case.
2791 break;
2792 }
2793
2794 // Read and process a record.
2795 Record.clear();
2796 StringRef Blob;
2797 auto RecordType =
2798 (ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob);
2799
2800 // If we're not loading an AST context, we don't care about most records.
2801 if (!ContextObj) {
2802 switch (RecordType) {
2803 case IDENTIFIER_TABLE:
2804 case IDENTIFIER_OFFSET:
2805 case INTERESTING_IDENTIFIERS:
2806 case STATISTICS:
2807 case PP_CONDITIONAL_STACK:
2808 case PP_COUNTER_VALUE:
2809 case SOURCE_LOCATION_OFFSETS:
2810 case MODULE_OFFSET_MAP:
2811 case SOURCE_MANAGER_LINE_TABLE:
2812 case SOURCE_LOCATION_PRELOADS:
2813 case PPD_ENTITIES_OFFSETS:
2814 case HEADER_SEARCH_TABLE:
2815 case IMPORTED_MODULES:
2816 case MACRO_OFFSET:
2817 break;
2818 default:
2819 continue;
2820 }
2821 }
2822
2823 switch (RecordType) {
2824 default: // Default behavior: ignore.
2825 break;
2826
2827 case TYPE_OFFSET: {
2828 if (F.LocalNumTypes != 0) {
2829 Error("duplicate TYPE_OFFSET record in AST file");
2830 return Failure;
2831 }
2832 F.TypeOffsets = (const uint32_t *)Blob.data();
2833 F.LocalNumTypes = Record[0];
2834 unsigned LocalBaseTypeIndex = Record[1];
2835 F.BaseTypeIndex = getTotalNumTypes();
2836
2837 if (F.LocalNumTypes > 0) {
2838 // Introduce the global -> local mapping for types within this module.
2839 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2840
2841 // Introduce the local -> global mapping for types within this module.
2842 F.TypeRemap.insertOrReplace(
2843 std::make_pair(LocalBaseTypeIndex,
2844 F.BaseTypeIndex - LocalBaseTypeIndex));
2845
2846 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2847 }
2848 break;
2849 }
2850
2851 case DECL_OFFSET: {
2852 if (F.LocalNumDecls != 0) {
2853 Error("duplicate DECL_OFFSET record in AST file");
2854 return Failure;
2855 }
2856 F.DeclOffsets = (const DeclOffset *)Blob.data();
2857 F.LocalNumDecls = Record[0];
2858 unsigned LocalBaseDeclID = Record[1];
2859 F.BaseDeclID = getTotalNumDecls();
2860
2861 if (F.LocalNumDecls > 0) {
2862 // Introduce the global -> local mapping for declarations within this
2863 // module.
2864 GlobalDeclMap.insert(
2865 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2866
2867 // Introduce the local -> global mapping for declarations within this
2868 // module.
2869 F.DeclRemap.insertOrReplace(
2870 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2871
2872 // Introduce the global -> local mapping for declarations within this
2873 // module.
2874 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2875
2876 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2877 }
2878 break;
2879 }
2880
2881 case TU_UPDATE_LEXICAL: {
2882 DeclContext *TU = ContextObj->getTranslationUnitDecl();
2883 LexicalContents Contents(
2884 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2885 Blob.data()),
2886 static_cast<unsigned int>(Blob.size() / 4));
2887 TULexicalDecls.push_back(std::make_pair(&F, Contents));
2888 TU->setHasExternalLexicalStorage(true);
2889 break;
2890 }
2891
2892 case UPDATE_VISIBLE: {
2893 unsigned Idx = 0;
2894 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2895 auto *Data = (const unsigned char*)Blob.data();
2896 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2897 // If we've already loaded the decl, perform the updates when we finish
2898 // loading this block.
2899 if (Decl *D = GetExistingDecl(ID))
2900 PendingUpdateRecords.push_back(
2901 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
2902 break;
2903 }
2904
2905 case IDENTIFIER_TABLE:
2906 F.IdentifierTableData = Blob.data();
2907 if (Record[0]) {
2908 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2909 (const unsigned char *)F.IdentifierTableData + Record[0],
2910 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2911 (const unsigned char *)F.IdentifierTableData,
2912 ASTIdentifierLookupTrait(*this, F));
2913
2914 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2915 }
2916 break;
2917
2918 case IDENTIFIER_OFFSET: {
2919 if (F.LocalNumIdentifiers != 0) {
2920 Error("duplicate IDENTIFIER_OFFSET record in AST file");
2921 return Failure;
2922 }
2923 F.IdentifierOffsets = (const uint32_t *)Blob.data();
2924 F.LocalNumIdentifiers = Record[0];
2925 unsigned LocalBaseIdentifierID = Record[1];
2926 F.BaseIdentifierID = getTotalNumIdentifiers();
2927
2928 if (F.LocalNumIdentifiers > 0) {
2929 // Introduce the global -> local mapping for identifiers within this
2930 // module.
2931 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2932 &F));
2933
2934 // Introduce the local -> global mapping for identifiers within this
2935 // module.
2936 F.IdentifierRemap.insertOrReplace(
2937 std::make_pair(LocalBaseIdentifierID,
2938 F.BaseIdentifierID - LocalBaseIdentifierID));
2939
2940 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2941 + F.LocalNumIdentifiers);
2942 }
2943 break;
2944 }
2945
2946 case INTERESTING_IDENTIFIERS:
2947 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2948 break;
2949
2950 case EAGERLY_DESERIALIZED_DECLS:
2951 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2952 // about "interesting" decls (for instance, if we're building a module).
2953 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2954 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2955 break;
2956
2957 case MODULAR_CODEGEN_DECLS:
2958 // FIXME: Skip reading this record if our ASTConsumer doesn't care about
2959 // them (ie: if we're not codegenerating this module).
2960 if (F.Kind == MK_MainFile)
2961 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2962 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2963 break;
2964
2965 case SPECIAL_TYPES:
2966 if (SpecialTypes.empty()) {
2967 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2968 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2969 break;
2970 }
2971
2972 if (SpecialTypes.size() != Record.size()) {
2973 Error("invalid special-types record");
2974 return Failure;
2975 }
2976
2977 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2978 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2979 if (!SpecialTypes[I])
2980 SpecialTypes[I] = ID;
2981 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2982 // merge step?
2983 }
2984 break;
2985
2986 case STATISTICS:
2987 TotalNumStatements += Record[0];
2988 TotalNumMacros += Record[1];
2989 TotalLexicalDeclContexts += Record[2];
2990 TotalVisibleDeclContexts += Record[3];
2991 break;
2992
2993 case UNUSED_FILESCOPED_DECLS:
2994 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2995 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2996 break;
2997
2998 case DELEGATING_CTORS:
2999 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3000 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
3001 break;
3002
3003 case WEAK_UNDECLARED_IDENTIFIERS:
3004 if (Record.size() % 4 != 0) {
3005 Error("invalid weak identifiers record");
3006 return Failure;
3007 }
3008
3009 // FIXME: Ignore weak undeclared identifiers from non-original PCH
3010 // files. This isn't the way to do it :)
3011 WeakUndeclaredIdentifiers.clear();
3012
3013 // Translate the weak, undeclared identifiers into global IDs.
3014 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
3015 WeakUndeclaredIdentifiers.push_back(
3016 getGlobalIdentifierID(F, Record[I++]));
3017 WeakUndeclaredIdentifiers.push_back(
3018 getGlobalIdentifierID(F, Record[I++]));
3019 WeakUndeclaredIdentifiers.push_back(
3020 ReadSourceLocation(F, Record, I).getRawEncoding());
3021 WeakUndeclaredIdentifiers.push_back(Record[I++]);
3022 }
3023 break;
3024
3025 case SELECTOR_OFFSETS: {
3026 F.SelectorOffsets = (const uint32_t *)Blob.data();
3027 F.LocalNumSelectors = Record[0];
3028 unsigned LocalBaseSelectorID = Record[1];
3029 F.BaseSelectorID = getTotalNumSelectors();
3030
3031 if (F.LocalNumSelectors > 0) {
3032 // Introduce the global -> local mapping for selectors within this
3033 // module.
3034 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
3035
3036 // Introduce the local -> global mapping for selectors within this
3037 // module.
3038 F.SelectorRemap.insertOrReplace(
3039 std::make_pair(LocalBaseSelectorID,
3040 F.BaseSelectorID - LocalBaseSelectorID));
3041
3042 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
3043 }
3044 break;
3045 }
3046
3047 case METHOD_POOL:
3048 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
3049 if (Record[0])
3050 F.SelectorLookupTable
3051 = ASTSelectorLookupTable::Create(
3052 F.SelectorLookupTableData + Record[0],
3053 F.SelectorLookupTableData,
3054 ASTSelectorLookupTrait(*this, F));
3055 TotalNumMethodPoolEntries += Record[1];
3056 break;
3057
3058 case REFERENCED_SELECTOR_POOL:
3059 if (!Record.empty()) {
3060 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
3061 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
3062 Record[Idx++]));
3063 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
3064 getRawEncoding());
3065 }
3066 }
3067 break;
3068
3069 case PP_CONDITIONAL_STACK:
3070 if (!Record.empty()) {
3071 unsigned Idx = 0, End = Record.size() - 1;
3072 bool ReachedEOFWhileSkipping = Record[Idx++];
3073 llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
3074 if (ReachedEOFWhileSkipping) {
3075 SourceLocation HashToken = ReadSourceLocation(F, Record, Idx);
3076 SourceLocation IfTokenLoc = ReadSourceLocation(F, Record, Idx);
3077 bool FoundNonSkipPortion = Record[Idx++];
3078 bool FoundElse = Record[Idx++];
3079 SourceLocation ElseLoc = ReadSourceLocation(F, Record, Idx);
3080 SkipInfo.emplace(HashToken, IfTokenLoc, FoundNonSkipPortion,
3081 FoundElse, ElseLoc);
3082 }
3083 SmallVector<PPConditionalInfo, 4> ConditionalStack;
3084 while (Idx < End) {
3085 auto Loc = ReadSourceLocation(F, Record, Idx);
3086 bool WasSkipping = Record[Idx++];
3087 bool FoundNonSkip = Record[Idx++];
3088 bool FoundElse = Record[Idx++];
3089 ConditionalStack.push_back(
3090 {Loc, WasSkipping, FoundNonSkip, FoundElse});
3091 }
3092 PP.setReplayablePreambleConditionalStack(ConditionalStack, SkipInfo);
3093 }
3094 break;
3095
3096 case PP_COUNTER_VALUE:
3097 if (!Record.empty() && Listener)
3098 Listener->ReadCounter(F, Record[0]);
3099 break;
3100
3101 case FILE_SORTED_DECLS:
3102 F.FileSortedDecls = (const DeclID *)Blob.data();
3103 F.NumFileSortedDecls = Record[0];
3104 break;
3105
3106 case SOURCE_LOCATION_OFFSETS: {
3107 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
3108 F.LocalNumSLocEntries = Record[0];
3109 unsigned SLocSpaceSize = Record[1];
3110 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
3111 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
3112 SLocSpaceSize);
3113 if (!F.SLocEntryBaseID) {
3114 Error("ran out of source locations");
3115 break;
3116 }
3117 // Make our entry in the range map. BaseID is negative and growing, so
3118 // we invert it. Because we invert it, though, we need the other end of
3119 // the range.
3120 unsigned RangeStart =
3121 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
3122 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
3123 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
3124
3125 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
3126 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0)(((F.SLocEntryBaseOffset & (1U << 31U)) == 0) ? static_cast
<void> (0) : __assert_fail ("(F.SLocEntryBaseOffset & (1U << 31U)) == 0"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3126, __PRETTY_FUNCTION__))
;
3127 GlobalSLocOffsetMap.insert(
3128 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
3129 - SLocSpaceSize,&F));
3130
3131 // Initialize the remapping table.
3132 // Invalid stays invalid.
3133 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
3134 // This module. Base was 2 when being compiled.
3135 F.SLocRemap.insertOrReplace(std::make_pair(2U,
3136 static_cast<int>(F.SLocEntryBaseOffset - 2)));
3137
3138 TotalNumSLocEntries += F.LocalNumSLocEntries;
3139 break;
3140 }
3141
3142 case MODULE_OFFSET_MAP:
3143 F.ModuleOffsetMap = Blob;
3144 break;
3145
3146 case SOURCE_MANAGER_LINE_TABLE:
3147 if (ParseLineTable(F, Record))
3148 return Failure;
3149 break;
3150
3151 case SOURCE_LOCATION_PRELOADS: {
3152 // Need to transform from the local view (1-based IDs) to the global view,
3153 // which is based off F.SLocEntryBaseID.
3154 if (!F.PreloadSLocEntries.empty()) {
3155 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
3156 return Failure;
3157 }
3158
3159 F.PreloadSLocEntries.swap(Record);
3160 break;
3161 }
3162
3163 case EXT_VECTOR_DECLS:
3164 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3165 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
3166 break;
3167
3168 case VTABLE_USES:
3169 if (Record.size() % 3 != 0) {
3170 Error("Invalid VTABLE_USES record");
3171 return Failure;
3172 }
3173
3174 // Later tables overwrite earlier ones.
3175 // FIXME: Modules will have some trouble with this. This is clearly not
3176 // the right way to do this.
3177 VTableUses.clear();
3178
3179 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
3180 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
3181 VTableUses.push_back(
3182 ReadSourceLocation(F, Record, Idx).getRawEncoding());
3183 VTableUses.push_back(Record[Idx++]);
3184 }
3185 break;
3186
3187 case PENDING_IMPLICIT_INSTANTIATIONS:
3188 if (PendingInstantiations.size() % 2 != 0) {
3189 Error("Invalid existing PendingInstantiations");
3190 return Failure;
3191 }
3192
3193 if (Record.size() % 2 != 0) {
3194 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
3195 return Failure;
3196 }
3197
3198 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3199 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
3200 PendingInstantiations.push_back(
3201 ReadSourceLocation(F, Record, I).getRawEncoding());
3202 }
3203 break;
3204
3205 case SEMA_DECL_REFS:
3206 if (Record.size() != 3) {
3207 Error("Invalid SEMA_DECL_REFS block");
3208 return Failure;
3209 }
3210 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3211 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3212 break;
3213
3214 case PPD_ENTITIES_OFFSETS: {
3215 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
3216 assert(Blob.size() % sizeof(PPEntityOffset) == 0)((Blob.size() % sizeof(PPEntityOffset) == 0) ? static_cast<
void> (0) : __assert_fail ("Blob.size() % sizeof(PPEntityOffset) == 0"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3216, __PRETTY_FUNCTION__))
;
3217 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
3218
3219 unsigned LocalBasePreprocessedEntityID = Record[0];
3220
3221 unsigned StartingID;
3222 if (!PP.getPreprocessingRecord())
3223 PP.createPreprocessingRecord();
3224 if (!PP.getPreprocessingRecord()->getExternalSource())
3225 PP.getPreprocessingRecord()->SetExternalSource(*this);
3226 StartingID
3227 = PP.getPreprocessingRecord()
3228 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3229 F.BasePreprocessedEntityID = StartingID;
3230
3231 if (F.NumPreprocessedEntities > 0) {
3232 // Introduce the global -> local mapping for preprocessed entities in
3233 // this module.
3234 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3235
3236 // Introduce the local -> global mapping for preprocessed entities in
3237 // this module.
3238 F.PreprocessedEntityRemap.insertOrReplace(
3239 std::make_pair(LocalBasePreprocessedEntityID,
3240 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3241 }
3242
3243 break;
3244 }
3245
3246 case PPD_SKIPPED_RANGES: {
3247 F.PreprocessedSkippedRangeOffsets = (const PPSkippedRange*)Blob.data();
3248 assert(Blob.size() % sizeof(PPSkippedRange) == 0)((Blob.size() % sizeof(PPSkippedRange) == 0) ? static_cast<
void> (0) : __assert_fail ("Blob.size() % sizeof(PPSkippedRange) == 0"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3248, __PRETTY_FUNCTION__))
;
3249 F.NumPreprocessedSkippedRanges = Blob.size() / sizeof(PPSkippedRange);
3250
3251 if (!PP.getPreprocessingRecord())
3252 PP.createPreprocessingRecord();
3253 if (!PP.getPreprocessingRecord()->getExternalSource())
3254 PP.getPreprocessingRecord()->SetExternalSource(*this);
3255 F.BasePreprocessedSkippedRangeID = PP.getPreprocessingRecord()
3256 ->allocateSkippedRanges(F.NumPreprocessedSkippedRanges);
3257
3258 if (F.NumPreprocessedSkippedRanges > 0)
3259 GlobalSkippedRangeMap.insert(
3260 std::make_pair(F.BasePreprocessedSkippedRangeID, &F));
3261 break;
3262 }
3263
3264 case DECL_UPDATE_OFFSETS:
3265 if (Record.size() % 2 != 0) {
3266 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3267 return Failure;
3268 }
3269 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3270 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3271 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3272
3273 // If we've already loaded the decl, perform the updates when we finish
3274 // loading this block.
3275 if (Decl *D = GetExistingDecl(ID))
3276 PendingUpdateRecords.push_back(
3277 PendingUpdateRecord(ID, D, /*JustLoaded=*/false));
3278 }
3279 break;
3280
3281 case OBJC_CATEGORIES_MAP:
3282 if (F.LocalNumObjCCategoriesInMap != 0) {
3283 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3284 return Failure;
3285 }
3286
3287 F.LocalNumObjCCategoriesInMap = Record[0];
3288 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3289 break;
3290
3291 case OBJC_CATEGORIES:
3292 F.ObjCCategories.swap(Record);
3293 break;
3294
3295 case CUDA_SPECIAL_DECL_REFS:
3296 // Later tables overwrite earlier ones.
3297 // FIXME: Modules will have trouble with this.
3298 CUDASpecialDeclRefs.clear();
3299 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3300 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3301 break;
3302
3303 case HEADER_SEARCH_TABLE:
3304 F.HeaderFileInfoTableData = Blob.data();
3305 F.LocalNumHeaderFileInfos = Record[1];
3306 if (Record[0]) {
3307 F.HeaderFileInfoTable
3308 = HeaderFileInfoLookupTable::Create(
3309 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3310 (const unsigned char *)F.HeaderFileInfoTableData,
3311 HeaderFileInfoTrait(*this, F,
3312 &PP.getHeaderSearchInfo(),
3313 Blob.data() + Record[2]));
3314
3315 PP.getHeaderSearchInfo().SetExternalSource(this);
3316 if (!PP.getHeaderSearchInfo().getExternalLookup())
3317 PP.getHeaderSearchInfo().SetExternalLookup(this);
3318 }
3319 break;
3320
3321 case FP_PRAGMA_OPTIONS:
3322 // Later tables overwrite earlier ones.
3323 FPPragmaOptions.swap(Record);
3324 break;
3325
3326 case OPENCL_EXTENSIONS:
3327 for (unsigned I = 0, E = Record.size(); I != E; ) {
3328 auto Name = ReadString(Record, I);
3329 auto &Opt = OpenCLExtensions.OptMap[Name];
3330 Opt.Supported = Record[I++] != 0;
3331 Opt.Enabled = Record[I++] != 0;
3332 Opt.Avail = Record[I++];
3333 Opt.Core = Record[I++];
3334 }
3335 break;
3336
3337 case OPENCL_EXTENSION_TYPES:
3338 for (unsigned I = 0, E = Record.size(); I != E;) {
3339 auto TypeID = static_cast<::TypeID>(Record[I++]);
3340 auto *Type = GetType(TypeID).getTypePtr();
3341 auto NumExt = static_cast<unsigned>(Record[I++]);
3342 for (unsigned II = 0; II != NumExt; ++II) {
3343 auto Ext = ReadString(Record, I);
3344 OpenCLTypeExtMap[Type].insert(Ext);
3345 }
3346 }
3347 break;
3348
3349 case OPENCL_EXTENSION_DECLS:
3350 for (unsigned I = 0, E = Record.size(); I != E;) {
3351 auto DeclID = static_cast<::DeclID>(Record[I++]);
3352 auto *Decl = GetDecl(DeclID);
3353 auto NumExt = static_cast<unsigned>(Record[I++]);
3354 for (unsigned II = 0; II != NumExt; ++II) {
3355 auto Ext = ReadString(Record, I);
3356 OpenCLDeclExtMap[Decl].insert(Ext);
3357 }
3358 }
3359 break;
3360
3361 case TENTATIVE_DEFINITIONS:
3362 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3363 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3364 break;
3365
3366 case KNOWN_NAMESPACES:
3367 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3368 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3369 break;
3370
3371 case UNDEFINED_BUT_USED:
3372 if (UndefinedButUsed.size() % 2 != 0) {
3373 Error("Invalid existing UndefinedButUsed");
3374 return Failure;
3375 }
3376
3377 if (Record.size() % 2 != 0) {
3378 Error("invalid undefined-but-used record");
3379 return Failure;
3380 }
3381 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3382 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3383 UndefinedButUsed.push_back(
3384 ReadSourceLocation(F, Record, I).getRawEncoding());
3385 }
3386 break;
3387
3388 case DELETE_EXPRS_TO_ANALYZE:
3389 for (unsigned I = 0, N = Record.size(); I != N;) {
3390 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3391 const uint64_t Count = Record[I++];
3392 DelayedDeleteExprs.push_back(Count);
3393 for (uint64_t C = 0; C < Count; ++C) {
3394 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3395 bool IsArrayForm = Record[I++] == 1;
3396 DelayedDeleteExprs.push_back(IsArrayForm);
3397 }
3398 }
3399 break;
3400
3401 case IMPORTED_MODULES:
3402 if (!F.isModule()) {
3403 // If we aren't loading a module (which has its own exports), make
3404 // all of the imported modules visible.
3405 // FIXME: Deal with macros-only imports.
3406 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3407 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3408 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3409 if (GlobalID) {
3410 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3411 if (DeserializationListener)
3412 DeserializationListener->ModuleImportRead(GlobalID, Loc);
3413 }
3414 }
3415 }
3416 break;
3417
3418 case MACRO_OFFSET: {
3419 if (F.LocalNumMacros != 0) {
3420 Error("duplicate MACRO_OFFSET record in AST file");
3421 return Failure;
3422 }
3423 F.MacroOffsets = (const uint32_t *)Blob.data();
3424 F.LocalNumMacros = Record[0];
3425 unsigned LocalBaseMacroID = Record[1];
3426 F.BaseMacroID = getTotalNumMacros();
3427
3428 if (F.LocalNumMacros > 0) {
3429 // Introduce the global -> local mapping for macros within this module.
3430 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3431
3432 // Introduce the local -> global mapping for macros within this module.
3433 F.MacroRemap.insertOrReplace(
3434 std::make_pair(LocalBaseMacroID,
3435 F.BaseMacroID - LocalBaseMacroID));
3436
3437 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3438 }
3439 break;
3440 }
3441
3442 case LATE_PARSED_TEMPLATE:
3443 LateParsedTemplates.append(Record.begin(), Record.end());
3444 break;
3445
3446 case OPTIMIZE_PRAGMA_OPTIONS:
3447 if (Record.size() != 1) {
3448 Error("invalid pragma optimize record");
3449 return Failure;
3450 }
3451 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3452 break;
3453
3454 case MSSTRUCT_PRAGMA_OPTIONS:
3455 if (Record.size() != 1) {
3456 Error("invalid pragma ms_struct record");
3457 return Failure;
3458 }
3459 PragmaMSStructState = Record[0];
3460 break;
3461
3462 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3463 if (Record.size() != 2) {
3464 Error("invalid pragma ms_struct record");
3465 return Failure;
3466 }
3467 PragmaMSPointersToMembersState = Record[0];
3468 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3469 break;
3470
3471 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3472 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3473 UnusedLocalTypedefNameCandidates.push_back(
3474 getGlobalDeclID(F, Record[I]));
3475 break;
3476
3477 case CUDA_PRAGMA_FORCE_HOST_DEVICE_DEPTH:
3478 if (Record.size() != 1) {
3479 Error("invalid cuda pragma options record");
3480 return Failure;
3481 }
3482 ForceCUDAHostDeviceDepth = Record[0];
3483 break;
3484
3485 case PACK_PRAGMA_OPTIONS: {
3486 if (Record.size() < 3) {
3487 Error("invalid pragma pack record");
3488 return Failure;
3489 }
3490 PragmaPackCurrentValue = Record[0];
3491 PragmaPackCurrentLocation = ReadSourceLocation(F, Record[1]);
3492 unsigned NumStackEntries = Record[2];
3493 unsigned Idx = 3;
3494 // Reset the stack when importing a new module.
3495 PragmaPackStack.clear();
3496 for (unsigned I = 0; I < NumStackEntries; ++I) {
3497 PragmaPackStackEntry Entry;
3498 Entry.Value = Record[Idx++];
3499 Entry.Location = ReadSourceLocation(F, Record[Idx++]);
3500 Entry.PushLocation = ReadSourceLocation(F, Record[Idx++]);
3501 PragmaPackStrings.push_back(ReadString(Record, Idx));
3502 Entry.SlotLabel = PragmaPackStrings.back();
3503 PragmaPackStack.push_back(Entry);
3504 }
3505 break;
3506 }
3507 }
3508 }
3509}
3510
3511void ASTReader::ReadModuleOffsetMap(ModuleFile &F) const {
3512 assert(!F.ModuleOffsetMap.empty() && "no module offset map to read")((!F.ModuleOffsetMap.empty() && "no module offset map to read"
) ? static_cast<void> (0) : __assert_fail ("!F.ModuleOffsetMap.empty() && \"no module offset map to read\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3512, __PRETTY_FUNCTION__))
;
3513
3514 // Additional remapping information.
3515 const unsigned char *Data = (const unsigned char*)F.ModuleOffsetMap.data();
3516 const unsigned char *DataEnd = Data + F.ModuleOffsetMap.size();
3517 F.ModuleOffsetMap = StringRef();
3518
3519 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
3520 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
3521 F.SLocRemap.insert(std::make_pair(0U, 0));
3522 F.SLocRemap.insert(std::make_pair(2U, 1));
3523 }
3524
3525 // Continuous range maps we may be updating in our module.
3526 using RemapBuilder = ContinuousRangeMap<uint32_t, int, 2>::Builder;
3527 RemapBuilder SLocRemap(F.SLocRemap);
3528 RemapBuilder IdentifierRemap(F.IdentifierRemap);
3529 RemapBuilder MacroRemap(F.MacroRemap);
3530 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
3531 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
3532 RemapBuilder SelectorRemap(F.SelectorRemap);
3533 RemapBuilder DeclRemap(F.DeclRemap);
3534 RemapBuilder TypeRemap(F.TypeRemap);
3535
3536 while (Data < DataEnd) {
3537 // FIXME: Looking up dependency modules by filename is horrible. Let's
3538 // start fixing this with prebuilt and explicit modules and see how it
3539 // goes...
3540 using namespace llvm::support;
3541 ModuleKind Kind = static_cast<ModuleKind>(
3542 endian::readNext<uint8_t, little, unaligned>(Data));
3543 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
3544 StringRef Name = StringRef((const char*)Data, Len);
3545 Data += Len;
3546 ModuleFile *OM = (Kind == MK_PrebuiltModule || Kind == MK_ExplicitModule
3547 ? ModuleMgr.lookupByModuleName(Name)
3548 : ModuleMgr.lookupByFileName(Name));
3549 if (!OM) {
3550 std::string Msg =
3551 "SourceLocation remap refers to unknown module, cannot find ";
3552 Msg.append(Name);
3553 Error(Msg);
3554 return;
3555 }
3556
3557 uint32_t SLocOffset =
3558 endian::readNext<uint32_t, little, unaligned>(Data);
3559 uint32_t IdentifierIDOffset =
3560 endian::readNext<uint32_t, little, unaligned>(Data);
3561 uint32_t MacroIDOffset =
3562 endian::readNext<uint32_t, little, unaligned>(Data);
3563 uint32_t PreprocessedEntityIDOffset =
3564 endian::readNext<uint32_t, little, unaligned>(Data);
3565 uint32_t SubmoduleIDOffset =
3566 endian::readNext<uint32_t, little, unaligned>(Data);
3567 uint32_t SelectorIDOffset =
3568 endian::readNext<uint32_t, little, unaligned>(Data);
3569 uint32_t DeclIDOffset =
3570 endian::readNext<uint32_t, little, unaligned>(Data);
3571 uint32_t TypeIndexOffset =
3572 endian::readNext<uint32_t, little, unaligned>(Data);
3573
3574 uint32_t None = std::numeric_limits<uint32_t>::max();
3575
3576 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
3577 RemapBuilder &Remap) {
3578 if (Offset != None)
3579 Remap.insert(std::make_pair(Offset,
3580 static_cast<int>(BaseOffset - Offset)));
3581 };
3582 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
3583 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
3584 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
3585 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
3586 PreprocessedEntityRemap);
3587 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
3588 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
3589 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
3590 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
3591
3592 // Global -> local mappings.
3593 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
3594 }
3595}
3596
3597ASTReader::ASTReadResult
3598ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3599 const ModuleFile *ImportedBy,
3600 unsigned ClientLoadCapabilities) {
3601 unsigned Idx = 0;
3602 F.ModuleMapPath = ReadPath(F, Record, Idx);
3603
3604 // Try to resolve ModuleName in the current header search context and
3605 // verify that it is found in the same module map file as we saved. If the
3606 // top-level AST file is a main file, skip this check because there is no
3607 // usable header search context.
3608 assert(!F.ModuleName.empty() &&((!F.ModuleName.empty() && "MODULE_NAME should come before MODULE_MAP_FILE"
) ? static_cast<void> (0) : __assert_fail ("!F.ModuleName.empty() && \"MODULE_NAME should come before MODULE_MAP_FILE\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3609, __PRETTY_FUNCTION__))
3609 "MODULE_NAME should come before MODULE_MAP_FILE")((!F.ModuleName.empty() && "MODULE_NAME should come before MODULE_MAP_FILE"
) ? static_cast<void> (0) : __assert_fail ("!F.ModuleName.empty() && \"MODULE_NAME should come before MODULE_MAP_FILE\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3609, __PRETTY_FUNCTION__))
;
3610 if (F.Kind == MK_ImplicitModule && ModuleMgr.begin()->Kind != MK_MainFile) {
3611 // An implicitly-loaded module file should have its module listed in some
3612 // module map file that we've already loaded.
3613 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3614 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3615 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3616 // Don't emit module relocation error if we have -fno-validate-pch
3617 if (!PP.getPreprocessorOpts().DisablePCHValidation && !ModMap) {
3618 assert(ImportedBy && "top-level import should be verified")((ImportedBy && "top-level import should be verified"
) ? static_cast<void> (0) : __assert_fail ("ImportedBy && \"top-level import should be verified\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3618, __PRETTY_FUNCTION__))
;
3619 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3620 if (auto *ASTFE = M ? M->getASTFile() : nullptr) {
3621 // This module was defined by an imported (explicit) module.
3622 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3623 << ASTFE->getName();
3624 } else {
3625 // This module was built with a different module map.
3626 Diag(diag::err_imported_module_not_found)
3627 << F.ModuleName << F.FileName << ImportedBy->FileName
3628 << F.ModuleMapPath;
3629 // In case it was imported by a PCH, there's a chance the user is
3630 // just missing to include the search path to the directory containing
3631 // the modulemap.
3632 if (ImportedBy->Kind == MK_PCH)
3633 Diag(diag::note_imported_by_pch_module_not_found)
3634 << llvm::sys::path::parent_path(F.ModuleMapPath);
3635 }
3636 }
3637 return OutOfDate;
3638 }
3639
3640 assert(M->Name == F.ModuleName && "found module with different name")((M->Name == F.ModuleName && "found module with different name"
) ? static_cast<void> (0) : __assert_fail ("M->Name == F.ModuleName && \"found module with different name\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3640, __PRETTY_FUNCTION__))
;
3641
3642 // Check the primary module map file.
3643 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3644 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3645 assert(ModMap && "found module is missing module map file")((ModMap && "found module is missing module map file"
) ? static_cast<void> (0) : __assert_fail ("ModMap && \"found module is missing module map file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3645, __PRETTY_FUNCTION__))
;
3646 assert(ImportedBy && "top-level import should be verified")((ImportedBy && "top-level import should be verified"
) ? static_cast<void> (0) : __assert_fail ("ImportedBy && \"top-level import should be verified\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3646, __PRETTY_FUNCTION__))
;
3647 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3648 Diag(diag::err_imported_module_modmap_changed)
3649 << F.ModuleName << ImportedBy->FileName
3650 << ModMap->getName() << F.ModuleMapPath;
3651 return OutOfDate;
3652 }
3653
3654 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3655 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3656 // FIXME: we should use input files rather than storing names.
3657 std::string Filename = ReadPath(F, Record, Idx);
3658 const FileEntry *F =
3659 FileMgr.getFile(Filename, false, false);
3660 if (F == nullptr) {
3661 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3662 Error("could not find file '" + Filename +"' referenced by AST file");
3663 return OutOfDate;
3664 }
3665 AdditionalStoredMaps.insert(F);
3666 }
3667
3668 // Check any additional module map files (e.g. module.private.modulemap)
3669 // that are not in the pcm.
3670 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3671 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3672 // Remove files that match
3673 // Note: SmallPtrSet::erase is really remove
3674 if (!AdditionalStoredMaps.erase(ModMap)) {
3675 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3676 Diag(diag::err_module_different_modmap)
3677 << F.ModuleName << /*new*/0 << ModMap->getName();
3678 return OutOfDate;
3679 }
3680 }
3681 }
3682
3683 // Check any additional module map files that are in the pcm, but not
3684 // found in header search. Cases that match are already removed.
3685 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3686 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3687 Diag(diag::err_module_different_modmap)
3688 << F.ModuleName << /*not new*/1 << ModMap->getName();
3689 return OutOfDate;
3690 }
3691 }
3692
3693 if (Listener)
3694 Listener->ReadModuleMapFile(F.ModuleMapPath);
3695 return Success;
3696}
3697
3698/// Move the given method to the back of the global list of methods.
3699static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3700 // Find the entry for this selector in the method pool.
3701 Sema::GlobalMethodPool::iterator Known
3702 = S.MethodPool.find(Method->getSelector());
3703 if (Known == S.MethodPool.end())
3704 return;
3705
3706 // Retrieve the appropriate method list.
3707 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3708 : Known->second.second;
3709 bool Found = false;
3710 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3711 if (!Found) {
3712 if (List->getMethod() == Method) {
3713 Found = true;
3714 } else {
3715 // Keep searching.
3716 continue;
3717 }
3718 }
3719
3720 if (List->getNext())
3721 List->setMethod(List->getNext()->getMethod());
3722 else
3723 List->setMethod(Method);
3724 }
3725}
3726
3727void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3728 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?")((Owner->NameVisibility != Module::Hidden && "nothing to make visible?"
) ? static_cast<void> (0) : __assert_fail ("Owner->NameVisibility != Module::Hidden && \"nothing to make visible?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3728, __PRETTY_FUNCTION__))
;
3729 for (Decl *D : Names) {
3730 bool wasHidden = D->isHidden();
3731 D->setVisibleDespiteOwningModule();
3732
3733 if (wasHidden && SemaObj) {
3734 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3735 moveMethodToBackOfGlobalList(*SemaObj, Method);
3736 }
3737 }
3738 }
3739}
3740
3741void ASTReader::makeModuleVisible(Module *Mod,
3742 Module::NameVisibilityKind NameVisibility,
3743 SourceLocation ImportLoc) {
3744 llvm::SmallPtrSet<Module *, 4> Visited;
3745 SmallVector<Module *, 4> Stack;
3746 Stack.push_back(Mod);
3747 while (!Stack.empty()) {
3748 Mod = Stack.pop_back_val();
3749
3750 if (NameVisibility <= Mod->NameVisibility) {
3751 // This module already has this level of visibility (or greater), so
3752 // there is nothing more to do.
3753 continue;
3754 }
3755
3756 if (!Mod->isAvailable()) {
3757 // Modules that aren't available cannot be made visible.
3758 continue;
3759 }
3760
3761 // Update the module's name visibility.
3762 Mod->NameVisibility = NameVisibility;
3763
3764 // If we've already deserialized any names from this module,
3765 // mark them as visible.
3766 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3767 if (Hidden != HiddenNamesMap.end()) {
3768 auto HiddenNames = std::move(*Hidden);
3769 HiddenNamesMap.erase(Hidden);
3770 makeNamesVisible(HiddenNames.second, HiddenNames.first);
3771 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&((HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
"making names visible added hidden names") ? static_cast<
void> (0) : __assert_fail ("HiddenNamesMap.find(Mod) == HiddenNamesMap.end() && \"making names visible added hidden names\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3772, __PRETTY_FUNCTION__))
3772 "making names visible added hidden names")((HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
"making names visible added hidden names") ? static_cast<
void> (0) : __assert_fail ("HiddenNamesMap.find(Mod) == HiddenNamesMap.end() && \"making names visible added hidden names\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 3772, __PRETTY_FUNCTION__))
;
3773 }
3774
3775 // Push any exported modules onto the stack to be marked as visible.
3776 SmallVector<Module *, 16> Exports;
3777 Mod->getExportedModules(Exports);
3778 for (SmallVectorImpl<Module *>::iterator
3779 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3780 Module *Exported = *I;
3781 if (Visited.insert(Exported).second)
3782 Stack.push_back(Exported);
3783 }
3784 }
3785}
3786
3787/// We've merged the definition \p MergedDef into the existing definition
3788/// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
3789/// visible.
3790void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
3791 NamedDecl *MergedDef) {
3792 if (Def->isHidden()) {
3793 // If MergedDef is visible or becomes visible, make the definition visible.
3794 if (!MergedDef->isHidden())
3795 Def->setVisibleDespiteOwningModule();
3796 else {
3797 getContext().mergeDefinitionIntoModule(
3798 Def, MergedDef->getImportedOwningModule(),
3799 /*NotifyListeners*/ false);
3800 PendingMergedDefinitionsToDeduplicate.insert(Def);
3801 }
3802 }
3803}
3804
3805bool ASTReader::loadGlobalIndex() {
3806 if (GlobalIndex)
3807 return false;
3808
3809 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3810 !PP.getLangOpts().Modules)
3811 return true;
3812
3813 // Try to load the global index.
3814 TriedLoadingGlobalIndex = true;
3815 StringRef ModuleCachePath
3816 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3817 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3818 = GlobalModuleIndex::readIndex(ModuleCachePath);
3819 if (!Result.first)
3820 return true;
3821
3822 GlobalIndex.reset(Result.first);
3823 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3824 return false;
3825}
3826
3827bool ASTReader::isGlobalIndexUnavailable() const {
3828 return PP.getLangOpts().Modules && UseGlobalIndex &&
3829 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3830}
3831
3832static void updateModuleTimestamp(ModuleFile &MF) {
3833 // Overwrite the timestamp file contents so that file's mtime changes.
3834 std::string TimestampFilename = MF.getTimestampFilename();
3835 std::error_code EC;
3836 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3837 if (EC)
3838 return;
3839 OS << "Timestamp file\n";
3840 OS.close();
3841 OS.clear_error(); // Avoid triggering a fatal error.
3842}
3843
3844/// Given a cursor at the start of an AST file, scan ahead and drop the
3845/// cursor into the start of the given block ID, returning false on success and
3846/// true on failure.
3847static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3848 while (true) {
3849 llvm::BitstreamEntry Entry = Cursor.advance();
3850 switch (Entry.Kind) {
3851 case llvm::BitstreamEntry::Error:
3852 case llvm::BitstreamEntry::EndBlock:
3853 return true;
3854
3855 case llvm::BitstreamEntry::Record:
3856 // Ignore top-level records.
3857 Cursor.skipRecord(Entry.ID);
3858 break;
3859
3860 case llvm::BitstreamEntry::SubBlock:
3861 if (Entry.ID == BlockID) {
3862 if (Cursor.EnterSubBlock(BlockID))
3863 return true;
3864 // Found it!
3865 return false;
3866 }
3867
3868 if (Cursor.SkipBlock())
3869 return true;
3870 }
3871 }
3872}
3873
3874ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
3875 ModuleKind Type,
3876 SourceLocation ImportLoc,
3877 unsigned ClientLoadCapabilities,
3878 SmallVectorImpl<ImportedSubmodule> *Imported) {
3879 llvm::SaveAndRestore<SourceLocation>
3880 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3881
3882 // Defer any pending actions until we get to the end of reading the AST file.
3883 Deserializing AnASTFile(this);
3884
3885 // Bump the generation number.
3886 unsigned PreviousGeneration = 0;
3887 if (ContextObj)
3888 PreviousGeneration = incrementGeneration(*ContextObj);
3889
3890 unsigned NumModules = ModuleMgr.size();
3891 SmallVector<ImportedModule, 4> Loaded;
3892 switch (ASTReadResult ReadResult =
3893 ReadASTCore(FileName, Type, ImportLoc,
3894 /*ImportedBy=*/nullptr, Loaded, 0, 0,
3895 ASTFileSignature(), ClientLoadCapabilities)) {
3896 case Failure:
3897 case Missing:
3898 case OutOfDate:
3899 case VersionMismatch:
3900 case ConfigurationMismatch:
3901 case HadErrors: {
3902 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3903 for (const ImportedModule &IM : Loaded)
3904 LoadedSet.insert(IM.Mod);
3905
3906 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, LoadedSet,
3907 PP.getLangOpts().Modules
3908 ? &PP.getHeaderSearchInfo().getModuleMap()
3909 : nullptr);
3910
3911 // If we find that any modules are unusable, the global index is going
3912 // to be out-of-date. Just remove it.
3913 GlobalIndex.reset();
3914 ModuleMgr.setGlobalIndex(nullptr);
3915 return ReadResult;
3916 }
3917 case Success:
3918 break;
3919 }
3920
3921 // Here comes stuff that we only do once the entire chain is loaded.
3922
3923 // Load the AST blocks of all of the modules that we loaded.
3924 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3925 MEnd = Loaded.end();
3926 M != MEnd; ++M) {
3927 ModuleFile &F = *M->Mod;
3928
3929 // Read the AST block.
3930 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3931 return Result;
3932
3933 // Read the extension blocks.
3934 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3935 if (ASTReadResult Result = ReadExtensionBlock(F))
3936 return Result;
3937 }
3938
3939 // Once read, set the ModuleFile bit base offset and update the size in
3940 // bits of all files we've seen.
3941 F.GlobalBitOffset = TotalModulesSizeInBits;
3942 TotalModulesSizeInBits += F.SizeInBits;
3943 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3944
3945 // Preload SLocEntries.
3946 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3947 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3948 // Load it through the SourceManager and don't call ReadSLocEntry()
3949 // directly because the entry may have already been loaded in which case
3950 // calling ReadSLocEntry() directly would trigger an assertion in
3951 // SourceManager.
3952 SourceMgr.getLoadedSLocEntryByID(Index);
3953 }
3954
3955 // Map the original source file ID into the ID space of the current
3956 // compilation.
3957 if (F.OriginalSourceFileID.isValid()) {
3958 F.OriginalSourceFileID = FileID::get(
3959 F.SLocEntryBaseID + F.OriginalSourceFileID.getOpaqueValue() - 1);
3960 }
3961
3962 // Preload all the pending interesting identifiers by marking them out of
3963 // date.
3964 for (auto Offset : F.PreloadIdentifierOffsets) {
3965 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3966 F.IdentifierTableData + Offset);
3967
3968 ASTIdentifierLookupTrait Trait(*this, F);
3969 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3970 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3971 auto &II = PP.getIdentifierTable().getOwn(Key);
3972 II.setOutOfDate(true);
3973
3974 // Mark this identifier as being from an AST file so that we can track
3975 // whether we need to serialize it.
3976 markIdentifierFromAST(*this, II);
3977
3978 // Associate the ID with the identifier so that the writer can reuse it.
3979 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3980 SetIdentifierInfo(ID, &II);
3981 }
3982 }
3983
3984 // Setup the import locations and notify the module manager that we've
3985 // committed to these module files.
3986 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3987 MEnd = Loaded.end();
3988 M != MEnd; ++M) {
3989 ModuleFile &F = *M->Mod;
3990
3991 ModuleMgr.moduleFileAccepted(&F);
3992
3993 // Set the import location.
3994 F.DirectImportLoc = ImportLoc;
3995 // FIXME: We assume that locations from PCH / preamble do not need
3996 // any translation.
3997 if (!M->ImportedBy)
3998 F.ImportLoc = M->ImportLoc;
3999 else
4000 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
4001 }
4002
4003 if (!PP.getLangOpts().CPlusPlus ||
4004 (Type != MK_ImplicitModule && Type != MK_ExplicitModule &&
4005 Type != MK_PrebuiltModule)) {
4006 // Mark all of the identifiers in the identifier table as being out of date,
4007 // so that various accessors know to check the loaded modules when the
4008 // identifier is used.
4009 //
4010 // For C++ modules, we don't need information on many identifiers (just
4011 // those that provide macros or are poisoned), so we mark all of
4012 // the interesting ones via PreloadIdentifierOffsets.
4013 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
4014 IdEnd = PP.getIdentifierTable().end();
4015 Id != IdEnd; ++Id)
4016 Id->second->setOutOfDate(true);
4017 }
4018 // Mark selectors as out of date.
4019 for (auto Sel : SelectorGeneration)
4020 SelectorOutOfDate[Sel.first] = true;
4021
4022 // Resolve any unresolved module exports.
4023 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
4024 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
4025 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
4026 Module *ResolvedMod = getSubmodule(GlobalID);
4027
4028 switch (Unresolved.Kind) {
4029 case UnresolvedModuleRef::Conflict:
4030 if (ResolvedMod) {
4031 Module::Conflict Conflict;
4032 Conflict.Other = ResolvedMod;
4033 Conflict.Message = Unresolved.String.str();
4034 Unresolved.Mod->Conflicts.push_back(Conflict);
4035 }
4036 continue;
4037
4038 case UnresolvedModuleRef::Import:
4039 if (ResolvedMod)
4040 Unresolved.Mod->Imports.insert(ResolvedMod);
4041 continue;
4042
4043 case UnresolvedModuleRef::Export:
4044 if (ResolvedMod || Unresolved.IsWildcard)
4045 Unresolved.Mod->Exports.push_back(
4046 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
4047 continue;
4048 }
4049 }
4050 UnresolvedModuleRefs.clear();
4051
4052 if (Imported)
4053 Imported->append(ImportedModules.begin(),
4054 ImportedModules.end());
4055
4056 // FIXME: How do we load the 'use'd modules? They may not be submodules.
4057 // Might be unnecessary as use declarations are only used to build the
4058 // module itself.
4059
4060 if (ContextObj)
4061 InitializeContext();
4062
4063 if (SemaObj)
4064 UpdateSema();
4065
4066 if (DeserializationListener)
4067 DeserializationListener->ReaderInitialized(this);
4068
4069 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
4070 if (PrimaryModule.OriginalSourceFileID.isValid()) {
4071 // If this AST file is a precompiled preamble, then set the
4072 // preamble file ID of the source manager to the file source file
4073 // from which the preamble was built.
4074 if (Type == MK_Preamble) {
4075 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
4076 } else if (Type == MK_MainFile) {
4077 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
4078 }
4079 }
4080
4081 // For any Objective-C class definitions we have already loaded, make sure
4082 // that we load any additional categories.
4083 if (ContextObj) {
4084 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
4085 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
4086 ObjCClassesLoaded[I],
4087 PreviousGeneration);
4088 }
4089 }
4090
4091 if (PP.getHeaderSearchInfo()
4092 .getHeaderSearchOpts()
4093 .ModulesValidateOncePerBuildSession) {
4094 // Now we are certain that the module and all modules it depends on are
4095 // up to date. Create or update timestamp files for modules that are
4096 // located in the module cache (not for PCH files that could be anywhere
4097 // in the filesystem).
4098 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
4099 ImportedModule &M = Loaded[I];
4100 if (M.Mod->Kind == MK_ImplicitModule) {
4101 updateModuleTimestamp(*M.Mod);
4102 }
4103 }
4104 }
4105
4106 return Success;
4107}
4108
4109static ASTFileSignature readASTFileSignature(StringRef PCH);
4110
4111/// Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
4112static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
4113 return Stream.canSkipToPos(4) &&
4114 Stream.Read(8) == 'C' &&
4115 Stream.Read(8) == 'P' &&
4116 Stream.Read(8) == 'C' &&
4117 Stream.Read(8) == 'H';
4118}
4119
4120static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
4121 switch (Kind) {
4122 case MK_PCH:
4123 return 0; // PCH
4124 case MK_ImplicitModule:
4125 case MK_ExplicitModule:
4126 case MK_PrebuiltModule:
4127 return 1; // module
4128 case MK_MainFile:
4129 case MK_Preamble:
4130 return 2; // main source file
4131 }
4132 llvm_unreachable("unknown module kind")::llvm::llvm_unreachable_internal("unknown module kind", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4132)
;
4133}
4134
4135ASTReader::ASTReadResult
4136ASTReader::ReadASTCore(StringRef FileName,
4137 ModuleKind Type,
4138 SourceLocation ImportLoc,
4139 ModuleFile *ImportedBy,
4140 SmallVectorImpl<ImportedModule> &Loaded,
4141 off_t ExpectedSize, time_t ExpectedModTime,
4142 ASTFileSignature ExpectedSignature,
4143 unsigned ClientLoadCapabilities) {
4144 ModuleFile *M;
4145 std::string ErrorStr;
4146 ModuleManager::AddModuleResult AddResult
4147 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
4148 getGeneration(), ExpectedSize, ExpectedModTime,
4149 ExpectedSignature, readASTFileSignature,
4150 M, ErrorStr);
4151
4152 switch (AddResult) {
4153 case ModuleManager::AlreadyLoaded:
4154 Diag(diag::remark_module_import)
4155 << M->ModuleName << M->FileName << (ImportedBy ? true : false)
4156 << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());
4157 return Success;
4158
4159 case ModuleManager::NewlyLoaded:
4160 // Load module file below.
4161 break;
4162
4163 case ModuleManager::Missing:
4164 // The module file was missing; if the client can handle that, return
4165 // it.
4166 if (ClientLoadCapabilities & ARR_Missing)
4167 return Missing;
4168
4169 // Otherwise, return an error.
4170 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
4171 << FileName << !ErrorStr.empty()
4172 << ErrorStr;
4173 return Failure;
4174
4175 case ModuleManager::OutOfDate:
4176 // We couldn't load the module file because it is out-of-date. If the
4177 // client can handle out-of-date, return it.
4178 if (ClientLoadCapabilities & ARR_OutOfDate)
4179 return OutOfDate;
4180
4181 // Otherwise, return an error.
4182 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
4183 << FileName << !ErrorStr.empty()
4184 << ErrorStr;
4185 return Failure;
4186 }
4187
4188 assert(M && "Missing module file")((M && "Missing module file") ? static_cast<void>
(0) : __assert_fail ("M && \"Missing module file\"",
"/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4188, __PRETTY_FUNCTION__))
;
4189
4190 bool ShouldFinalizePCM = false;
4191 auto FinalizeOrDropPCM = llvm::make_scope_exit([&]() {
4192 auto &MC = getModuleManager().getModuleCache();
4193 if (ShouldFinalizePCM)
4194 MC.finalizePCM(FileName);
4195 else
4196 MC.tryToDropPCM(FileName);
4197 });
4198 ModuleFile &F = *M;
4199 BitstreamCursor &Stream = F.Stream;
4200 Stream = BitstreamCursor(PCHContainerRdr.ExtractPCH(*F.Buffer));
4201 F.SizeInBits = F.Buffer->getBufferSize() * 8;
4202
4203 // Sniff for the signature.
4204 if (!startsWithASTFileMagic(Stream)) {
4205 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
4206 << FileName;
4207 return Failure;
4208 }
4209
4210 // This is used for compatibility with older PCH formats.
4211 bool HaveReadControlBlock = false;
4212 while (true) {
4213 llvm::BitstreamEntry Entry = Stream.advance();
4214
4215 switch (Entry.Kind) {
4216 case llvm::BitstreamEntry::Error:
4217 case llvm::BitstreamEntry::Record:
4218 case llvm::BitstreamEntry::EndBlock:
4219 Error("invalid record at top-level of AST file");
4220 return Failure;
4221
4222 case llvm::BitstreamEntry::SubBlock:
4223 break;
4224 }
4225
4226 switch (Entry.ID) {
4227 case CONTROL_BLOCK_ID:
4228 HaveReadControlBlock = true;
4229 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
4230 case Success:
4231 // Check that we didn't try to load a non-module AST file as a module.
4232 //
4233 // FIXME: Should we also perform the converse check? Loading a module as
4234 // a PCH file sort of works, but it's a bit wonky.
4235 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule ||
4236 Type == MK_PrebuiltModule) &&
4237 F.ModuleName.empty()) {
4238 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
4239 if (Result != OutOfDate ||
4240 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
4241 Diag(diag::err_module_file_not_module) << FileName;
4242 return Result;
4243 }
4244 break;
4245
4246 case Failure: return Failure;
4247 case Missing: return Missing;
4248 case OutOfDate: return OutOfDate;
4249 case VersionMismatch: return VersionMismatch;
4250 case ConfigurationMismatch: return ConfigurationMismatch;
4251 case HadErrors: return HadErrors;
4252 }
4253 break;
4254
4255 case AST_BLOCK_ID:
4256 if (!HaveReadControlBlock) {
4257 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
4258 Diag(diag::err_pch_version_too_old);
4259 return VersionMismatch;
4260 }
4261
4262 // Record that we've loaded this module.
4263 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
4264 ShouldFinalizePCM = true;
4265 return Success;
4266
4267 case UNHASHED_CONTROL_BLOCK_ID:
4268 // This block is handled using look-ahead during ReadControlBlock. We
4269 // shouldn't get here!
4270 Error("malformed block record in AST file");
4271 return Failure;
4272
4273 default:
4274 if (Stream.SkipBlock()) {
4275 Error("malformed block record in AST file");
4276 return Failure;
4277 }
4278 break;
4279 }
4280 }
4281
4282 llvm_unreachable("unexpected break; expected return")::llvm::llvm_unreachable_internal("unexpected break; expected return"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4282)
;
4283}
4284
4285ASTReader::ASTReadResult
4286ASTReader::readUnhashedControlBlock(ModuleFile &F, bool WasImportedBy,
4287 unsigned ClientLoadCapabilities) {
4288 const HeaderSearchOptions &HSOpts =
4289 PP.getHeaderSearchInfo().getHeaderSearchOpts();
4290 bool AllowCompatibleConfigurationMismatch =
4291 F.Kind == MK_ExplicitModule || F.Kind == MK_PrebuiltModule;
4292
4293 ASTReadResult Result = readUnhashedControlBlockImpl(
4294 &F, F.Data, ClientLoadCapabilities, AllowCompatibleConfigurationMismatch,
4295 Listener.get(),
4296 WasImportedBy ? false : HSOpts.ModulesValidateDiagnosticOptions);
4297
4298 // If F was directly imported by another module, it's implicitly validated by
4299 // the importing module.
4300 if (DisableValidation || WasImportedBy ||
4301 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
4302 return Success;
4303
4304 if (Result == Failure) {
4305 Error("malformed block record in AST file");
4306 return Failure;
4307 }
4308
4309 if (Result == OutOfDate && F.Kind == MK_ImplicitModule) {
4310 // If this module has already been finalized in the ModuleCache, we're stuck
4311 // with it; we can only load a single version of each module.
4312 //
4313 // This can happen when a module is imported in two contexts: in one, as a
4314 // user module; in another, as a system module (due to an import from
4315 // another module marked with the [system] flag). It usually indicates a
4316 // bug in the module map: this module should also be marked with [system].
4317 //
4318 // If -Wno-system-headers (the default), and the first import is as a
4319 // system module, then validation will fail during the as-user import,
4320 // since -Werror flags won't have been validated. However, it's reasonable
4321 // to treat this consistently as a system module.
4322 //
4323 // If -Wsystem-headers, the PCM on disk was built with
4324 // -Wno-system-headers, and the first import is as a user module, then
4325 // validation will fail during the as-system import since the PCM on disk
4326 // doesn't guarantee that -Werror was respected. However, the -Werror
4327 // flags were checked during the initial as-user import.
4328 if (getModuleManager().getModuleCache().isPCMFinal(F.FileName)) {
4329 Diag(diag::warn_module_system_bit_conflict) << F.FileName;
4330 return Success;
4331 }
4332 }
4333
4334 return Result;
4335}
4336
4337ASTReader::ASTReadResult ASTReader::readUnhashedControlBlockImpl(
4338 ModuleFile *F, llvm::StringRef StreamData, unsigned ClientLoadCapabilities,
4339 bool AllowCompatibleConfigurationMismatch, ASTReaderListener *Listener,
4340 bool ValidateDiagnosticOptions) {
4341 // Initialize a stream.
4342 BitstreamCursor Stream(StreamData);
4343
4344 // Sniff for the signature.
4345 if (!startsWithASTFileMagic(Stream))
4346 return Failure;
4347
4348 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4349 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4350 return Failure;
4351
4352 // Read all of the records in the options block.
4353 RecordData Record;
4354 ASTReadResult Result = Success;
4355 while (true) {
4356 llvm::BitstreamEntry Entry = Stream.advance();
4357
4358 switch (Entry.Kind) {
4359 case llvm::BitstreamEntry::Error:
4360 case llvm::BitstreamEntry::SubBlock:
4361 return Failure;
4362
4363 case llvm::BitstreamEntry::EndBlock:
4364 return Result;
4365
4366 case llvm::BitstreamEntry::Record:
4367 // The interesting case.
4368 break;
4369 }
4370
4371 // Read and process a record.
4372 Record.clear();
4373 switch (
4374 (UnhashedControlBlockRecordTypes)Stream.readRecord(Entry.ID, Record)) {
4375 case SIGNATURE:
4376 if (F)
4377 std::copy(Record.begin(), Record.end(), F->Signature.data());
4378 break;
4379 case DIAGNOSTIC_OPTIONS: {
4380 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
4381 if (Listener && ValidateDiagnosticOptions &&
4382 !AllowCompatibleConfigurationMismatch &&
4383 ParseDiagnosticOptions(Record, Complain, *Listener))
4384 Result = OutOfDate; // Don't return early. Read the signature.
4385 break;
4386 }
4387 case DIAG_PRAGMA_MAPPINGS:
4388 if (!F)
4389 break;
4390 if (F->PragmaDiagMappings.empty())
4391 F->PragmaDiagMappings.swap(Record);
4392 else
4393 F->PragmaDiagMappings.insert(F->PragmaDiagMappings.end(),
4394 Record.begin(), Record.end());
4395 break;
4396 }
4397 }
4398}
4399
4400/// Parse a record and blob containing module file extension metadata.
4401static bool parseModuleFileExtensionMetadata(
4402 const SmallVectorImpl<uint64_t> &Record,
4403 StringRef Blob,
4404 ModuleFileExtensionMetadata &Metadata) {
4405 if (Record.size() < 4) return true;
4406
4407 Metadata.MajorVersion = Record[0];
4408 Metadata.MinorVersion = Record[1];
4409
4410 unsigned BlockNameLen = Record[2];
4411 unsigned UserInfoLen = Record[3];
4412
4413 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
4414
4415 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
4416 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
4417 Blob.data() + BlockNameLen + UserInfoLen);
4418 return false;
4419}
4420
4421ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
4422 BitstreamCursor &Stream = F.Stream;
4423
4424 RecordData Record;
4425 while (true) {
4426 llvm::BitstreamEntry Entry = Stream.advance();
4427 switch (Entry.Kind) {
4428 case llvm::BitstreamEntry::SubBlock:
4429 if (Stream.SkipBlock())
4430 return Failure;
4431
4432 continue;
4433
4434 case llvm::BitstreamEntry::EndBlock:
4435 return Success;
4436
4437 case llvm::BitstreamEntry::Error:
4438 return HadErrors;
4439
4440 case llvm::BitstreamEntry::Record:
4441 break;
4442 }
4443
4444 Record.clear();
4445 StringRef Blob;
4446 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4447 switch (RecCode) {
4448 case EXTENSION_METADATA: {
4449 ModuleFileExtensionMetadata Metadata;
4450 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4451 return Failure;
4452
4453 // Find a module file extension with this block name.
4454 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
4455 if (Known == ModuleFileExtensions.end()) break;
4456
4457 // Form a reader.
4458 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
4459 F, Stream)) {
4460 F.ExtensionReaders.push_back(std::move(Reader));
4461 }
4462
4463 break;
4464 }
4465 }
4466 }
4467
4468 return Success;
4469}
4470
4471void ASTReader::InitializeContext() {
4472 assert(ContextObj && "no context to initialize")((ContextObj && "no context to initialize") ? static_cast
<void> (0) : __assert_fail ("ContextObj && \"no context to initialize\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4472, __PRETTY_FUNCTION__))
;
4473 ASTContext &Context = *ContextObj;
4474
4475 // If there's a listener, notify them that we "read" the translation unit.
4476 if (DeserializationListener)
4477 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
4478 Context.getTranslationUnitDecl());
4479
4480 // FIXME: Find a better way to deal with collisions between these
4481 // built-in types. Right now, we just ignore the problem.
4482
4483 // Load the special types.
4484 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
4485 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
4486 if (!Context.CFConstantStringTypeDecl)
4487 Context.setCFConstantStringType(GetType(String));
4488 }
4489
4490 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
4491 QualType FileType = GetType(File);
4492 if (FileType.isNull()) {
4493 Error("FILE type is NULL");
4494 return;
4495 }
4496
4497 if (!Context.FILEDecl) {
4498 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
4499 Context.setFILEDecl(Typedef->getDecl());
4500 else {
4501 const TagType *Tag = FileType->getAs<TagType>();
4502 if (!Tag) {
4503 Error("Invalid FILE type in AST file");
4504 return;
4505 }
4506 Context.setFILEDecl(Tag->getDecl());
4507 }
4508 }
4509 }
4510
4511 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
4512 QualType Jmp_bufType = GetType(Jmp_buf);
4513 if (Jmp_bufType.isNull()) {
4514 Error("jmp_buf type is NULL");
4515 return;
4516 }
4517
4518 if (!Context.jmp_bufDecl) {
4519 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
4520 Context.setjmp_bufDecl(Typedef->getDecl());
4521 else {
4522 const TagType *Tag = Jmp_bufType->getAs<TagType>();
4523 if (!Tag) {
4524 Error("Invalid jmp_buf type in AST file");
4525 return;
4526 }
4527 Context.setjmp_bufDecl(Tag->getDecl());
4528 }
4529 }
4530 }
4531
4532 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4533 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4534 if (Sigjmp_bufType.isNull()) {
4535 Error("sigjmp_buf type is NULL");
4536 return;
4537 }
4538
4539 if (!Context.sigjmp_bufDecl) {
4540 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4541 Context.setsigjmp_bufDecl(Typedef->getDecl());
4542 else {
4543 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4544 assert(Tag && "Invalid sigjmp_buf type in AST file")((Tag && "Invalid sigjmp_buf type in AST file") ? static_cast
<void> (0) : __assert_fail ("Tag && \"Invalid sigjmp_buf type in AST file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4544, __PRETTY_FUNCTION__))
;
4545 Context.setsigjmp_bufDecl(Tag->getDecl());
4546 }
4547 }
4548 }
4549
4550 if (unsigned ObjCIdRedef
4551 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4552 if (Context.ObjCIdRedefinitionType.isNull())
4553 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4554 }
4555
4556 if (unsigned ObjCClassRedef
4557 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4558 if (Context.ObjCClassRedefinitionType.isNull())
4559 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4560 }
4561
4562 if (unsigned ObjCSelRedef
4563 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4564 if (Context.ObjCSelRedefinitionType.isNull())
4565 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4566 }
4567
4568 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4569 QualType Ucontext_tType = GetType(Ucontext_t);
4570 if (Ucontext_tType.isNull()) {
4571 Error("ucontext_t type is NULL");
4572 return;
4573 }
4574
4575 if (!Context.ucontext_tDecl) {
4576 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4577 Context.setucontext_tDecl(Typedef->getDecl());
4578 else {
4579 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4580 assert(Tag && "Invalid ucontext_t type in AST file")((Tag && "Invalid ucontext_t type in AST file") ? static_cast
<void> (0) : __assert_fail ("Tag && \"Invalid ucontext_t type in AST file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4580, __PRETTY_FUNCTION__))
;
4581 Context.setucontext_tDecl(Tag->getDecl());
4582 }
4583 }
4584 }
4585 }
4586
4587 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4588
4589 // If there were any CUDA special declarations, deserialize them.
4590 if (!CUDASpecialDeclRefs.empty()) {
4591 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!")((CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"
) ? static_cast<void> (0) : __assert_fail ("CUDASpecialDeclRefs.size() == 1 && \"More decl refs than expected!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 4591, __PRETTY_FUNCTION__))
;
4592 Context.setcudaConfigureCallDecl(
4593 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4594 }
4595
4596 // Re-export any modules that were imported by a non-module AST file.
4597 // FIXME: This does not make macro-only imports visible again.
4598 for (auto &Import : ImportedModules) {
4599 if (Module *Imported = getSubmodule(Import.ID)) {
4600 makeModuleVisible(Imported, Module::AllVisible,
4601 /*ImportLoc=*/Import.ImportLoc);
4602 if (Import.ImportLoc.isValid())
4603 PP.makeModuleVisible(Imported, Import.ImportLoc);
4604 // FIXME: should we tell Sema to make the module visible too?
4605 }
4606 }
4607 ImportedModules.clear();
4608}
4609
4610void ASTReader::finalizeForWriting() {
4611 // Nothing to do for now.
4612}
4613
4614/// Reads and return the signature record from \p PCH's control block, or
4615/// else returns 0.
4616static ASTFileSignature readASTFileSignature(StringRef PCH) {
4617 BitstreamCursor Stream(PCH);
4618 if (!startsWithASTFileMagic(Stream))
4619 return ASTFileSignature();
4620
4621 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4622 if (SkipCursorToBlock(Stream, UNHASHED_CONTROL_BLOCK_ID))
4623 return ASTFileSignature();
4624
4625 // Scan for SIGNATURE inside the diagnostic options block.
4626 ASTReader::RecordData Record;
4627 while (true) {
4628 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4629 if (Entry.Kind != llvm::BitstreamEntry::Record)
4630 return ASTFileSignature();
4631
4632 Record.clear();
4633 StringRef Blob;
4634 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4635 return {{{(uint32_t)Record[0], (uint32_t)Record[1], (uint32_t)Record[2],
4636 (uint32_t)Record[3], (uint32_t)Record[4]}}};
4637 }
4638}
4639
4640/// Retrieve the name of the original source file name
4641/// directly from the AST file, without actually loading the AST
4642/// file.
4643std::string ASTReader::getOriginalSourceFile(
4644 const std::string &ASTFileName, FileManager &FileMgr,
4645 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4646 // Open the AST file.
4647 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4648 if (!Buffer) {
4649 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4650 << ASTFileName << Buffer.getError().message();
4651 return std::string();
4652 }
4653
4654 // Initialize the stream
4655 BitstreamCursor Stream(PCHContainerRdr.ExtractPCH(**Buffer));
4656
4657 // Sniff for the signature.
4658 if (!startsWithASTFileMagic(Stream)) {
4659 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4660 return std::string();
4661 }
4662
4663 // Scan for the CONTROL_BLOCK_ID block.
4664 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4665 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4666 return std::string();
4667 }
4668
4669 // Scan for ORIGINAL_FILE inside the control block.
4670 RecordData Record;
4671 while (true) {
4672 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4673 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4674 return std::string();
4675
4676 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4677 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4678 return std::string();
4679 }
4680
4681 Record.clear();
4682 StringRef Blob;
4683 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4684 return Blob.str();
4685 }
4686}
4687
4688namespace {
4689
4690 class SimplePCHValidator : public ASTReaderListener {
4691 const LangOptions &ExistingLangOpts;
4692 const TargetOptions &ExistingTargetOpts;
4693 const PreprocessorOptions &ExistingPPOpts;
4694 std::string ExistingModuleCachePath;
4695 FileManager &FileMgr;
4696
4697 public:
4698 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4699 const TargetOptions &ExistingTargetOpts,
4700 const PreprocessorOptions &ExistingPPOpts,
4701 StringRef ExistingModuleCachePath,
4702 FileManager &FileMgr)
4703 : ExistingLangOpts(ExistingLangOpts),
4704 ExistingTargetOpts(ExistingTargetOpts),
4705 ExistingPPOpts(ExistingPPOpts),
4706 ExistingModuleCachePath(ExistingModuleCachePath),
4707 FileMgr(FileMgr) {}
4708
4709 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4710 bool AllowCompatibleDifferences) override {
4711 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4712 AllowCompatibleDifferences);
4713 }
4714
4715 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4716 bool AllowCompatibleDifferences) override {
4717 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4718 AllowCompatibleDifferences);
4719 }
4720
4721 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4722 StringRef SpecificModuleCachePath,
4723 bool Complain) override {
4724 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4725 ExistingModuleCachePath,
4726 nullptr, ExistingLangOpts);
4727 }
4728
4729 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4730 bool Complain,
4731 std::string &SuggestedPredefines) override {
4732 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4733 SuggestedPredefines, ExistingLangOpts);
4734 }
4735 };
4736
4737} // namespace
4738
4739bool ASTReader::readASTFileControlBlock(
4740 StringRef Filename, FileManager &FileMgr,
4741 const PCHContainerReader &PCHContainerRdr,
4742 bool FindModuleFileExtensions,
4743 ASTReaderListener &Listener, bool ValidateDiagnosticOptions) {
4744 // Open the AST file.
4745 // FIXME: This allows use of the VFS; we do not allow use of the
4746 // VFS when actually loading a module.
4747 auto Buffer = FileMgr.getBufferForFile(Filename);
4748 if (!Buffer) {
4749 return true;
4750 }
4751
4752 // Initialize the stream
4753 StringRef Bytes = PCHContainerRdr.ExtractPCH(**Buffer);
4754 BitstreamCursor Stream(Bytes);
4755
4756 // Sniff for the signature.
4757 if (!startsWithASTFileMagic(Stream))
4758 return true;
4759
4760 // Scan for the CONTROL_BLOCK_ID block.
4761 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4762 return true;
4763
4764 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4765 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4766 bool NeedsImports = Listener.needsImportVisitation();
4767 BitstreamCursor InputFilesCursor;
4768
4769 RecordData Record;
4770 std::string ModuleDir;
4771 bool DoneWithControlBlock = false;
4772 while (!DoneWithControlBlock) {
4773 llvm::BitstreamEntry Entry = Stream.advance();
4774
4775 switch (Entry.Kind) {
4776 case llvm::BitstreamEntry::SubBlock: {
4777 switch (Entry.ID) {
4778 case OPTIONS_BLOCK_ID: {
4779 std::string IgnoredSuggestedPredefines;
4780 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4781 /*AllowCompatibleConfigurationMismatch*/ false,
4782 Listener, IgnoredSuggestedPredefines) != Success)
4783 return true;
4784 break;
4785 }
4786
4787 case INPUT_FILES_BLOCK_ID:
4788 InputFilesCursor = Stream;
4789 if (Stream.SkipBlock() ||
4790 (NeedsInputFiles &&
4791 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4792 return true;
4793 break;
4794
4795 default:
4796 if (Stream.SkipBlock())
4797 return true;
4798 break;
4799 }
4800
4801 continue;
4802 }
4803
4804 case llvm::BitstreamEntry::EndBlock:
4805 DoneWithControlBlock = true;
4806 break;
4807
4808 case llvm::BitstreamEntry::Error:
4809 return true;
4810
4811 case llvm::BitstreamEntry::Record:
4812 break;
4813 }
4814
4815 if (DoneWithControlBlock) break;
4816
4817 Record.clear();
4818 StringRef Blob;
4819 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4820 switch ((ControlRecordTypes)RecCode) {
4821 case METADATA:
4822 if (Record[0] != VERSION_MAJOR)
4823 return true;
4824 if (Listener.ReadFullVersionInformation(Blob))
4825 return true;
4826 break;
4827 case MODULE_NAME:
4828 Listener.ReadModuleName(Blob);
4829 break;
4830 case MODULE_DIRECTORY:
4831 ModuleDir = Blob;
4832 break;
4833 case MODULE_MAP_FILE: {
4834 unsigned Idx = 0;
4835 auto Path = ReadString(Record, Idx);
4836 ResolveImportedPath(Path, ModuleDir);
4837 Listener.ReadModuleMapFile(Path);
4838 break;
4839 }
4840 case INPUT_FILE_OFFSETS: {
4841 if (!NeedsInputFiles)
4842 break;
4843
4844 unsigned NumInputFiles = Record[0];
4845 unsigned NumUserFiles = Record[1];
4846 const llvm::support::unaligned_uint64_t *InputFileOffs =
4847 (const llvm::support::unaligned_uint64_t *)Blob.data();
4848 for (unsigned I = 0; I != NumInputFiles; ++I) {
4849 // Go find this input file.
4850 bool isSystemFile = I >= NumUserFiles;
4851
4852 if (isSystemFile && !NeedsSystemInputFiles)
4853 break; // the rest are system input files
4854
4855 BitstreamCursor &Cursor = InputFilesCursor;
4856 SavedStreamPosition SavedPosition(Cursor);
4857 Cursor.JumpToBit(InputFileOffs[I]);
4858
4859 unsigned Code = Cursor.ReadCode();
4860 RecordData Record;
4861 StringRef Blob;
4862 bool shouldContinue = false;
4863 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4864 case INPUT_FILE:
4865 bool Overridden = static_cast<bool>(Record[3]);
4866 std::string Filename = Blob;
4867 ResolveImportedPath(Filename, ModuleDir);
4868 shouldContinue = Listener.visitInputFile(
4869 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4870 break;
4871 }
4872 if (!shouldContinue)
4873 break;
4874 }
4875 break;
4876 }
4877
4878 case IMPORTS: {
4879 if (!NeedsImports)
4880 break;
4881
4882 unsigned Idx = 0, N = Record.size();
4883 while (Idx < N) {
4884 // Read information about the AST file.
4885 Idx += 1+1+1+1+5; // Kind, ImportLoc, Size, ModTime, Signature
4886 std::string ModuleName = ReadString(Record, Idx);
4887 std::string Filename = ReadString(Record, Idx);
4888 ResolveImportedPath(Filename, ModuleDir);
4889 Listener.visitImport(ModuleName, Filename);
4890 }
4891 break;
4892 }
4893
4894 default:
4895 // No other validation to perform.
4896 break;
4897 }
4898 }
4899
4900 // Look for module file extension blocks, if requested.
4901 if (FindModuleFileExtensions) {
4902 BitstreamCursor SavedStream = Stream;
4903 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4904 bool DoneWithExtensionBlock = false;
4905 while (!DoneWithExtensionBlock) {
4906 llvm::BitstreamEntry Entry = Stream.advance();
4907
4908 switch (Entry.Kind) {
4909 case llvm::BitstreamEntry::SubBlock:
4910 if (Stream.SkipBlock())
4911 return true;
4912
4913 continue;
4914
4915 case llvm::BitstreamEntry::EndBlock:
4916 DoneWithExtensionBlock = true;
4917 continue;
4918
4919 case llvm::BitstreamEntry::Error:
4920 return true;
4921
4922 case llvm::BitstreamEntry::Record:
4923 break;
4924 }
4925
4926 Record.clear();
4927 StringRef Blob;
4928 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4929 switch (RecCode) {
4930 case EXTENSION_METADATA: {
4931 ModuleFileExtensionMetadata Metadata;
4932 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4933 return true;
4934
4935 Listener.readModuleFileExtension(Metadata);
4936 break;
4937 }
4938 }
4939 }
4940 }
4941 Stream = SavedStream;
4942 }
4943
4944 // Scan for the UNHASHED_CONTROL_BLOCK_ID block.
4945 if (readUnhashedControlBlockImpl(
4946 nullptr, Bytes, ARR_ConfigurationMismatch | ARR_OutOfDate,
4947 /*AllowCompatibleConfigurationMismatch*/ false, &Listener,
4948 ValidateDiagnosticOptions) != Success)
4949 return true;
4950
4951 return false;
4952}
4953
4954bool ASTReader::isAcceptableASTFile(StringRef Filename, FileManager &FileMgr,
4955 const PCHContainerReader &PCHContainerRdr,
4956 const LangOptions &LangOpts,
4957 const TargetOptions &TargetOpts,
4958 const PreprocessorOptions &PPOpts,
4959 StringRef ExistingModuleCachePath) {
4960 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4961 ExistingModuleCachePath, FileMgr);
4962 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4963 /*FindModuleFileExtensions=*/false,
4964 validator,
4965 /*ValidateDiagnosticOptions=*/true);
4966}
4967
4968ASTReader::ASTReadResult
4969ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4970 // Enter the submodule block.
4971 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4972 Error("malformed submodule block record in AST file");
4973 return Failure;
4974 }
4975
4976 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4977 bool First = true;
4978 Module *CurrentModule = nullptr;
4979 RecordData Record;
4980 while (true) {
4981 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4982
4983 switch (Entry.Kind) {
4984 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4985 case llvm::BitstreamEntry::Error:
4986 Error("malformed block record in AST file");
4987 return Failure;
4988 case llvm::BitstreamEntry::EndBlock:
4989 return Success;
4990 case llvm::BitstreamEntry::Record:
4991 // The interesting case.
4992 break;
4993 }
4994
4995 // Read a record.
4996 StringRef Blob;
4997 Record.clear();
4998 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4999
5000 if ((Kind == SUBMODULE_METADATA) != First) {
5001 Error("submodule metadata record should be at beginning of block");
5002 return Failure;
5003 }
5004 First = false;
5005
5006 // Submodule information is only valid if we have a current module.
5007 // FIXME: Should we error on these cases?
5008 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
5009 Kind != SUBMODULE_DEFINITION)
5010 continue;
5011
5012 switch (Kind) {
5013 default: // Default behavior: ignore.
5014 break;
5015
5016 case SUBMODULE_DEFINITION: {
5017 if (Record.size() < 12) {
5018 Error("malformed module definition");
5019 return Failure;
5020 }
5021
5022 StringRef Name = Blob;
5023 unsigned Idx = 0;
5024 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
5025 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
5026 Module::ModuleKind Kind = (Module::ModuleKind)Record[Idx++];
5027 bool IsFramework = Record[Idx++];
5028 bool IsExplicit = Record[Idx++];
5029 bool IsSystem = Record[Idx++];
5030 bool IsExternC = Record[Idx++];
5031 bool InferSubmodules = Record[Idx++];
5032 bool InferExplicitSubmodules = Record[Idx++];
5033 bool InferExportWildcard = Record[Idx++];
5034 bool ConfigMacrosExhaustive = Record[Idx++];
5035 bool ModuleMapIsPrivate = Record[Idx++];
5036
5037 Module *ParentModule = nullptr;
5038 if (Parent)
5039 ParentModule = getSubmodule(Parent);
5040
5041 // Retrieve this (sub)module from the module map, creating it if
5042 // necessary.
5043 CurrentModule =
5044 ModMap.findOrCreateModule(Name, ParentModule, IsFramework, IsExplicit)
5045 .first;
5046
5047 // FIXME: set the definition loc for CurrentModule, or call
5048 // ModMap.setInferredModuleAllowedBy()
5049
5050 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
5051 if (GlobalIndex >= SubmodulesLoaded.size() ||
5052 SubmodulesLoaded[GlobalIndex]) {
5053 Error("too many submodules");
5054 return Failure;
5055 }
5056
5057 if (!ParentModule) {
5058 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
5059 // Don't emit module relocation error if we have -fno-validate-pch
5060 if (!PP.getPreprocessorOpts().DisablePCHValidation &&
5061 CurFile != F.File) {
5062 if (!Diags.isDiagnosticInFlight()) {
5063 Diag(diag::err_module_file_conflict)
5064 << CurrentModule->getTopLevelModuleName()
5065 << CurFile->getName()
5066 << F.File->getName();
5067 }
5068 return Failure;
5069 }
5070 }
5071
5072 CurrentModule->setASTFile(F.File);
5073 CurrentModule->PresumedModuleMapFile = F.ModuleMapPath;
5074 }
5075
5076 CurrentModule->Kind = Kind;
5077 CurrentModule->Signature = F.Signature;
5078 CurrentModule->IsFromModuleFile = true;
5079 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
5080 CurrentModule->IsExternC = IsExternC;
5081 CurrentModule->InferSubmodules = InferSubmodules;
5082 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
5083 CurrentModule->InferExportWildcard = InferExportWildcard;
5084 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
5085 CurrentModule->ModuleMapIsPrivate = ModuleMapIsPrivate;
5086 if (DeserializationListener)
5087 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
5088
5089 SubmodulesLoaded[GlobalIndex] = CurrentModule;
5090
5091 // Clear out data that will be replaced by what is in the module file.
5092 CurrentModule->LinkLibraries.clear();
5093 CurrentModule->ConfigMacros.clear();
5094 CurrentModule->UnresolvedConflicts.clear();
5095 CurrentModule->Conflicts.clear();
5096
5097 // The module is available unless it's missing a requirement; relevant
5098 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
5099 // Missing headers that were present when the module was built do not
5100 // make it unavailable -- if we got this far, this must be an explicitly
5101 // imported module file.
5102 CurrentModule->Requirements.clear();
5103 CurrentModule->MissingHeaders.clear();
5104 CurrentModule->IsMissingRequirement =
5105 ParentModule && ParentModule->IsMissingRequirement;
5106 CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
5107 break;
5108 }
5109
5110 case SUBMODULE_UMBRELLA_HEADER: {
5111 std::string Filename = Blob;
5112 ResolveImportedPath(F, Filename);
5113 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
5114 if (!CurrentModule->getUmbrellaHeader())
5115 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
5116 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
5117 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5118 Error("mismatched umbrella headers in submodule");
5119 return OutOfDate;
5120 }
5121 }
5122 break;
5123 }
5124
5125 case SUBMODULE_HEADER:
5126 case SUBMODULE_EXCLUDED_HEADER:
5127 case SUBMODULE_PRIVATE_HEADER:
5128 // We lazily associate headers with their modules via the HeaderInfo table.
5129 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
5130 // of complete filenames or remove it entirely.
5131 break;
5132
5133 case SUBMODULE_TEXTUAL_HEADER:
5134 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
5135 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
5136 // them here.
5137 break;
5138
5139 case SUBMODULE_TOPHEADER:
5140 CurrentModule->addTopHeaderFilename(Blob);
5141 break;
5142
5143 case SUBMODULE_UMBRELLA_DIR: {
5144 std::string Dirname = Blob;
5145 ResolveImportedPath(F, Dirname);
5146 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
5147 if (!CurrentModule->getUmbrellaDir())
5148 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
5149 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
5150 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
5151 Error("mismatched umbrella directories in submodule");
5152 return OutOfDate;
5153 }
5154 }
5155 break;
5156 }
5157
5158 case SUBMODULE_METADATA: {
5159 F.BaseSubmoduleID = getTotalNumSubmodules();
5160 F.LocalNumSubmodules = Record[0];
5161 unsigned LocalBaseSubmoduleID = Record[1];
5162 if (F.LocalNumSubmodules > 0) {
5163 // Introduce the global -> local mapping for submodules within this
5164 // module.
5165 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
5166
5167 // Introduce the local -> global mapping for submodules within this
5168 // module.
5169 F.SubmoduleRemap.insertOrReplace(
5170 std::make_pair(LocalBaseSubmoduleID,
5171 F.BaseSubmoduleID - LocalBaseSubmoduleID));
5172
5173 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
5174 }
5175 break;
5176 }
5177
5178 case SUBMODULE_IMPORTS:
5179 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
5180 UnresolvedModuleRef Unresolved;
5181 Unresolved.File = &F;
5182 Unresolved.Mod = CurrentModule;
5183 Unresolved.ID = Record[Idx];
5184 Unresolved.Kind = UnresolvedModuleRef::Import;
5185 Unresolved.IsWildcard = false;
5186 UnresolvedModuleRefs.push_back(Unresolved);
5187 }
5188 break;
5189
5190 case SUBMODULE_EXPORTS:
5191 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
5192 UnresolvedModuleRef Unresolved;
5193 Unresolved.File = &F;
5194 Unresolved.Mod = CurrentModule;
5195 Unresolved.ID = Record[Idx];
5196 Unresolved.Kind = UnresolvedModuleRef::Export;
5197 Unresolved.IsWildcard = Record[Idx + 1];
5198 UnresolvedModuleRefs.push_back(Unresolved);
5199 }
5200
5201 // Once we've loaded the set of exports, there's no reason to keep
5202 // the parsed, unresolved exports around.
5203 CurrentModule->UnresolvedExports.clear();
5204 break;
5205
5206 case SUBMODULE_REQUIRES:
5207 CurrentModule->addRequirement(Blob, Record[0], PP.getLangOpts(),
5208 PP.getTargetInfo());
5209 break;
5210
5211 case SUBMODULE_LINK_LIBRARY:
5212 ModMap.resolveLinkAsDependencies(CurrentModule);
5213 CurrentModule->LinkLibraries.push_back(
5214 Module::LinkLibrary(Blob, Record[0]));
5215 break;
5216
5217 case SUBMODULE_CONFIG_MACRO:
5218 CurrentModule->ConfigMacros.push_back(Blob.str());
5219 break;
5220
5221 case SUBMODULE_CONFLICT: {
5222 UnresolvedModuleRef Unresolved;
5223 Unresolved.File = &F;
5224 Unresolved.Mod = CurrentModule;
5225 Unresolved.ID = Record[0];
5226 Unresolved.Kind = UnresolvedModuleRef::Conflict;
5227 Unresolved.IsWildcard = false;
5228 Unresolved.String = Blob;
5229 UnresolvedModuleRefs.push_back(Unresolved);
5230 break;
5231 }
5232
5233 case SUBMODULE_INITIALIZERS: {
5234 if (!ContextObj)
5235 break;
5236 SmallVector<uint32_t, 16> Inits;
5237 for (auto &ID : Record)
5238 Inits.push_back(getGlobalDeclID(F, ID));
5239 ContextObj->addLazyModuleInitializers(CurrentModule, Inits);
5240 break;
5241 }
5242
5243 case SUBMODULE_EXPORT_AS:
5244 CurrentModule->ExportAsModule = Blob.str();
5245 ModMap.addLinkAsDependency(CurrentModule);
5246 break;
5247 }
5248 }
5249}
5250
5251/// Parse the record that corresponds to a LangOptions data
5252/// structure.
5253///
5254/// This routine parses the language options from the AST file and then gives
5255/// them to the AST listener if one is set.
5256///
5257/// \returns true if the listener deems the file unacceptable, false otherwise.
5258bool ASTReader::ParseLanguageOptions(const RecordData &Record,
5259 bool Complain,
5260 ASTReaderListener &Listener,
5261 bool AllowCompatibleDifferences) {
5262 LangOptions LangOpts;
5263 unsigned Idx = 0;
5264#define LANGOPT(Name, Bits, Default, Description) \
5265 LangOpts.Name = Record[Idx++];
5266#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
5267 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
5268#include "clang/Basic/LangOptions.def"
5269#define SANITIZER(NAME, ID) \
5270 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
5271#include "clang/Basic/Sanitizers.def"
5272
5273 for (unsigned N = Record[Idx++]; N; --N)
5274 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
5275
5276 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5277 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
5278 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
5279
5280 LangOpts.CurrentModule = ReadString(Record, Idx);
5281
5282 // Comment options.
5283 for (unsigned N = Record[Idx++]; N; --N) {
5284 LangOpts.CommentOpts.BlockCommandNames.push_back(
5285 ReadString(Record, Idx));
5286 }
5287 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5288
5289 // OpenMP offloading options.
5290 for (unsigned N = Record[Idx++]; N; --N) {
5291 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
5292 }
5293
5294 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
5295
5296 return Listener.ReadLanguageOptions(LangOpts, Complain,
5297 AllowCompatibleDifferences);
5298}
5299
5300bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
5301 ASTReaderListener &Listener,
5302 bool AllowCompatibleDifferences) {
5303 unsigned Idx = 0;
5304 TargetOptions TargetOpts;
5305 TargetOpts.Triple = ReadString(Record, Idx);
5306 TargetOpts.CPU = ReadString(Record, Idx);
5307 TargetOpts.ABI = ReadString(Record, Idx);
5308 for (unsigned N = Record[Idx++]; N; --N) {
5309 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
5310 }
5311 for (unsigned N = Record[Idx++]; N; --N) {
5312 TargetOpts.Features.push_back(ReadString(Record, Idx));
5313 }
5314
5315 return Listener.ReadTargetOptions(TargetOpts, Complain,
5316 AllowCompatibleDifferences);
5317}
5318
5319bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
5320 ASTReaderListener &Listener) {
5321 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
5322 unsigned Idx = 0;
5323#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
5324#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
5325 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
5326#include "clang/Basic/DiagnosticOptions.def"
5327
5328 for (unsigned N = Record[Idx++]; N; --N)
5329 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
5330 for (unsigned N = Record[Idx++]; N; --N)
5331 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
5332
5333 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
5334}
5335
5336bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
5337 ASTReaderListener &Listener) {
5338 FileSystemOptions FSOpts;
5339 unsigned Idx = 0;
5340 FSOpts.WorkingDir = ReadString(Record, Idx);
5341 return Listener.ReadFileSystemOptions(FSOpts, Complain);
5342}
5343
5344bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
5345 bool Complain,
5346 ASTReaderListener &Listener) {
5347 HeaderSearchOptions HSOpts;
5348 unsigned Idx = 0;
5349 HSOpts.Sysroot = ReadString(Record, Idx);
5350
5351 // Include entries.
5352 for (unsigned N = Record[Idx++]; N; --N) {
5353 std::string Path = ReadString(Record, Idx);
5354 frontend::IncludeDirGroup Group
5355 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5356 bool IsFramework = Record[Idx++];
5357 bool IgnoreSysRoot = Record[Idx++];
5358 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
5359 IgnoreSysRoot);
5360 }
5361
5362 // System header prefixes.
5363 for (unsigned N = Record[Idx++]; N; --N) {
5364 std::string Prefix = ReadString(Record, Idx);
5365 bool IsSystemHeader = Record[Idx++];
5366 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
5367 }
5368
5369 HSOpts.ResourceDir = ReadString(Record, Idx);
5370 HSOpts.ModuleCachePath = ReadString(Record, Idx);
5371 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
5372 HSOpts.DisableModuleHash = Record[Idx++];
5373 HSOpts.ImplicitModuleMaps = Record[Idx++];
5374 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5375 HSOpts.UseBuiltinIncludes = Record[Idx++];
5376 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5377 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5378 HSOpts.UseLibcxx = Record[Idx++];
5379 std::string SpecificModuleCachePath = ReadString(Record, Idx);
5380
5381 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
5382 Complain);
5383}
5384
5385bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
5386 bool Complain,
5387 ASTReaderListener &Listener,
5388 std::string &SuggestedPredefines) {
5389 PreprocessorOptions PPOpts;
5390 unsigned Idx = 0;
5391
5392 // Macro definitions/undefs
5393 for (unsigned N = Record[Idx++]; N; --N) {
5394 std::string Macro = ReadString(Record, Idx);
5395 bool IsUndef = Record[Idx++];
5396 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
5397 }
5398
5399 // Includes
5400 for (unsigned N = Record[Idx++]; N; --N) {
5401 PPOpts.Includes.push_back(ReadString(Record, Idx));
5402 }
5403
5404 // Macro Includes
5405 for (unsigned N = Record[Idx++]; N; --N) {
5406 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
5407 }
5408
5409 PPOpts.UsePredefines = Record[Idx++];
5410 PPOpts.DetailedRecord = Record[Idx++];
5411 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
5412 PPOpts.ObjCXXARCStandardLibrary =
5413 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
5414 SuggestedPredefines.clear();
5415 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
5416 SuggestedPredefines);
5417}
5418
5419std::pair<ModuleFile *, unsigned>
5420ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
5421 GlobalPreprocessedEntityMapType::iterator
5422 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
5423 assert(I != GlobalPreprocessedEntityMap.end() &&((I != GlobalPreprocessedEntityMap.end() && "Corrupted global preprocessed entity map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalPreprocessedEntityMap.end() && \"Corrupted global preprocessed entity map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5424, __PRETTY_FUNCTION__))
5424 "Corrupted global preprocessed entity map")((I != GlobalPreprocessedEntityMap.end() && "Corrupted global preprocessed entity map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalPreprocessedEntityMap.end() && \"Corrupted global preprocessed entity map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5424, __PRETTY_FUNCTION__))
;
5425 ModuleFile *M = I->second;
5426 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
5427 return std::make_pair(M, LocalIndex);
5428}
5429
5430llvm::iterator_range<PreprocessingRecord::iterator>
5431ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
5432 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
5433 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
5434 Mod.NumPreprocessedEntities);
5435
5436 return llvm::make_range(PreprocessingRecord::iterator(),
5437 PreprocessingRecord::iterator());
5438}
5439
5440llvm::iterator_range<ASTReader::ModuleDeclIterator>
5441ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
5442 return llvm::make_range(
5443 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
5444 ModuleDeclIterator(this, &Mod,
5445 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
5446}
5447
5448SourceRange ASTReader::ReadSkippedRange(unsigned GlobalIndex) {
5449 auto I = GlobalSkippedRangeMap.find(GlobalIndex);
5450 assert(I != GlobalSkippedRangeMap.end() &&((I != GlobalSkippedRangeMap.end() && "Corrupted global skipped range map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalSkippedRangeMap.end() && \"Corrupted global skipped range map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5451, __PRETTY_FUNCTION__))
5451 "Corrupted global skipped range map")((I != GlobalSkippedRangeMap.end() && "Corrupted global skipped range map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalSkippedRangeMap.end() && \"Corrupted global skipped range map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5451, __PRETTY_FUNCTION__))
;
5452 ModuleFile *M = I->second;
5453 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedSkippedRangeID;
5454 assert(LocalIndex < M->NumPreprocessedSkippedRanges)((LocalIndex < M->NumPreprocessedSkippedRanges) ? static_cast
<void> (0) : __assert_fail ("LocalIndex < M->NumPreprocessedSkippedRanges"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5454, __PRETTY_FUNCTION__))
;
5455 PPSkippedRange RawRange = M->PreprocessedSkippedRangeOffsets[LocalIndex];
5456 SourceRange Range(TranslateSourceLocation(*M, RawRange.getBegin()),
5457 TranslateSourceLocation(*M, RawRange.getEnd()));
5458 assert(Range.isValid())((Range.isValid()) ? static_cast<void> (0) : __assert_fail
("Range.isValid()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5458, __PRETTY_FUNCTION__))
;
5459 return Range;
5460}
5461
5462PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
5463 PreprocessedEntityID PPID = Index+1;
5464 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5465 ModuleFile &M = *PPInfo.first;
5466 unsigned LocalIndex = PPInfo.second;
5467 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5468
5469 if (!PP.getPreprocessingRecord()) {
5470 Error("no preprocessing record");
5471 return nullptr;
5472 }
5473
5474 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
5475 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
5476
5477 llvm::BitstreamEntry Entry =
5478 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
5479 if (Entry.Kind != llvm::BitstreamEntry::Record)
5480 return nullptr;
5481
5482 // Read the record.
5483 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
5484 TranslateSourceLocation(M, PPOffs.getEnd()));
5485 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
5486 StringRef Blob;
5487 RecordData Record;
5488 PreprocessorDetailRecordTypes RecType =
5489 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
5490 Entry.ID, Record, &Blob);
5491 switch (RecType) {
5492 case PPD_MACRO_EXPANSION: {
5493 bool isBuiltin = Record[0];
5494 IdentifierInfo *Name = nullptr;
5495 MacroDefinitionRecord *Def = nullptr;
5496 if (isBuiltin)
5497 Name = getLocalIdentifier(M, Record[1]);
5498 else {
5499 PreprocessedEntityID GlobalID =
5500 getGlobalPreprocessedEntityID(M, Record[1]);
5501 Def = cast<MacroDefinitionRecord>(
5502 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
5503 }
5504
5505 MacroExpansion *ME;
5506 if (isBuiltin)
5507 ME = new (PPRec) MacroExpansion(Name, Range);
5508 else
5509 ME = new (PPRec) MacroExpansion(Def, Range);
5510
5511 return ME;
5512 }
5513
5514 case PPD_MACRO_DEFINITION: {
5515 // Decode the identifier info and then check again; if the macro is
5516 // still defined and associated with the identifier,
5517 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
5518 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
5519
5520 if (DeserializationListener)
5521 DeserializationListener->MacroDefinitionRead(PPID, MD);
5522
5523 return MD;
5524 }
5525
5526 case PPD_INCLUSION_DIRECTIVE: {
5527 const char *FullFileNameStart = Blob.data() + Record[0];
5528 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
5529 const FileEntry *File = nullptr;
5530 if (!FullFileName.empty())
5531 File = PP.getFileManager().getFile(FullFileName);
5532
5533 // FIXME: Stable encoding
5534 InclusionDirective::InclusionKind Kind
5535 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
5536 InclusionDirective *ID
5537 = new (PPRec) InclusionDirective(PPRec, Kind,
5538 StringRef(Blob.data(), Record[0]),
5539 Record[1], Record[3],
5540 File,
5541 Range);
5542 return ID;
5543 }
5544 }
5545
5546 llvm_unreachable("Invalid PreprocessorDetailRecordTypes")::llvm::llvm_unreachable_internal("Invalid PreprocessorDetailRecordTypes"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5546)
;
5547}
5548
5549/// Find the next module that contains entities and return the ID
5550/// of the first entry.
5551///
5552/// \param SLocMapI points at a chunk of a module that contains no
5553/// preprocessed entities or the entities it contains are not the ones we are
5554/// looking for.
5555PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
5556 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
5557 ++SLocMapI;
5558 for (GlobalSLocOffsetMapType::const_iterator
5559 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
5560 ModuleFile &M = *SLocMapI->second;
5561 if (M.NumPreprocessedEntities)
5562 return M.BasePreprocessedEntityID;
5563 }
5564
5565 return getTotalNumPreprocessedEntities();
5566}
5567
5568namespace {
5569
5570struct PPEntityComp {
5571 const ASTReader &Reader;
5572 ModuleFile &M;
5573
5574 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) {}
5575
5576 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
5577 SourceLocation LHS = getLoc(L);
5578 SourceLocation RHS = getLoc(R);
5579 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5580 }
5581
5582 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
5583 SourceLocation LHS = getLoc(L);
5584 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5585 }
5586
5587 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5588 SourceLocation RHS = getLoc(R);
5589 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5590 }
5591
5592 SourceLocation getLoc(const PPEntityOffset &PPE) const {
5593 return Reader.TranslateSourceLocation(M, PPE.getBegin());
5594 }
5595};
5596
5597} // namespace
5598
5599PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5600 bool EndsAfter) const {
5601 if (SourceMgr.isLocalSourceLocation(Loc))
5602 return getTotalNumPreprocessedEntities();
5603
5604 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5605 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5606 assert(SLocMapI != GlobalSLocOffsetMap.end() &&((SLocMapI != GlobalSLocOffsetMap.end() && "Corrupted global sloc offset map"
) ? static_cast<void> (0) : __assert_fail ("SLocMapI != GlobalSLocOffsetMap.end() && \"Corrupted global sloc offset map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5607, __PRETTY_FUNCTION__))
5607 "Corrupted global sloc offset map")((SLocMapI != GlobalSLocOffsetMap.end() && "Corrupted global sloc offset map"
) ? static_cast<void> (0) : __assert_fail ("SLocMapI != GlobalSLocOffsetMap.end() && \"Corrupted global sloc offset map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5607, __PRETTY_FUNCTION__))
;
5608
5609 if (SLocMapI->second->NumPreprocessedEntities == 0)
5610 return findNextPreprocessedEntity(SLocMapI);
5611
5612 ModuleFile &M = *SLocMapI->second;
5613
5614 using pp_iterator = const PPEntityOffset *;
5615
5616 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5617 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5618
5619 size_t Count = M.NumPreprocessedEntities;
5620 size_t Half;
5621 pp_iterator First = pp_begin;
5622 pp_iterator PPI;
5623
5624 if (EndsAfter) {
5625 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5626 PPEntityComp(*this, M));
5627 } else {
5628 // Do a binary search manually instead of using std::lower_bound because
5629 // The end locations of entities may be unordered (when a macro expansion
5630 // is inside another macro argument), but for this case it is not important
5631 // whether we get the first macro expansion or its containing macro.
5632 while (Count > 0) {
5633 Half = Count / 2;
5634 PPI = First;
5635 std::advance(PPI, Half);
5636 if (SourceMgr.isBeforeInTranslationUnit(
5637 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5638 First = PPI;
5639 ++First;
5640 Count = Count - Half - 1;
5641 } else
5642 Count = Half;
5643 }
5644 }
5645
5646 if (PPI == pp_end)
5647 return findNextPreprocessedEntity(SLocMapI);
5648
5649 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5650}
5651
5652/// Returns a pair of [Begin, End) indices of preallocated
5653/// preprocessed entities that \arg Range encompasses.
5654std::pair<unsigned, unsigned>
5655 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5656 if (Range.isInvalid())
5657 return std::make_pair(0,0);
5658 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()))((!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin
())) ? static_cast<void> (0) : __assert_fail ("!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5658, __PRETTY_FUNCTION__))
;
5659
5660 PreprocessedEntityID BeginID =
5661 findPreprocessedEntity(Range.getBegin(), false);
5662 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5663 return std::make_pair(BeginID, EndID);
5664}
5665
5666/// Optionally returns true or false if the preallocated preprocessed
5667/// entity with index \arg Index came from file \arg FID.
5668Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5669 FileID FID) {
5670 if (FID.isInvalid())
5671 return false;
5672
5673 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5674 ModuleFile &M = *PPInfo.first;
5675 unsigned LocalIndex = PPInfo.second;
5676 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5677
5678 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5679 if (Loc.isInvalid())
5680 return false;
5681
5682 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5683 return true;
5684 else
5685 return false;
5686}
5687
5688namespace {
5689
5690 /// Visitor used to search for information about a header file.
5691 class HeaderFileInfoVisitor {
5692 const FileEntry *FE;
5693 Optional<HeaderFileInfo> HFI;
5694
5695 public:
5696 explicit HeaderFileInfoVisitor(const FileEntry *FE) : FE(FE) {}
5697
5698 bool operator()(ModuleFile &M) {
5699 HeaderFileInfoLookupTable *Table
5700 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5701 if (!Table)
5702 return false;
5703
5704 // Look in the on-disk hash table for an entry for this file name.
5705 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5706 if (Pos == Table->end())
5707 return false;
5708
5709 HFI = *Pos;
5710 return true;
5711 }
5712
5713 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5714 };
5715
5716} // namespace
5717
5718HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5719 HeaderFileInfoVisitor Visitor(FE);
5720 ModuleMgr.visit(Visitor);
5721 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5722 return *HFI;
5723
5724 return HeaderFileInfo();
5725}
5726
5727void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5728 using DiagState = DiagnosticsEngine::DiagState;
5729 SmallVector<DiagState *, 32> DiagStates;
5730
5731 for (ModuleFile &F : ModuleMgr) {
5732 unsigned Idx = 0;
5733 auto &Record = F.PragmaDiagMappings;
5734 if (Record.empty())
5735 continue;
5736
5737 DiagStates.clear();
5738
5739 auto ReadDiagState =
5740 [&](const DiagState &BasedOn, SourceLocation Loc,
5741 bool IncludeNonPragmaStates) -> DiagnosticsEngine::DiagState * {
5742 unsigned BackrefID = Record[Idx++];
5743 if (BackrefID != 0)
5744 return DiagStates[BackrefID - 1];
5745
5746 // A new DiagState was created here.
5747 Diag.DiagStates.push_back(BasedOn);
5748 DiagState *NewState = &Diag.DiagStates.back();
5749 DiagStates.push_back(NewState);
5750 unsigned Size = Record[Idx++];
5751 assert(Idx + Size * 2 <= Record.size() &&((Idx + Size * 2 <= Record.size() && "Invalid data, not enough diag/map pairs"
) ? static_cast<void> (0) : __assert_fail ("Idx + Size * 2 <= Record.size() && \"Invalid data, not enough diag/map pairs\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5752, __PRETTY_FUNCTION__))
5752 "Invalid data, not enough diag/map pairs")((Idx + Size * 2 <= Record.size() && "Invalid data, not enough diag/map pairs"
) ? static_cast<void> (0) : __assert_fail ("Idx + Size * 2 <= Record.size() && \"Invalid data, not enough diag/map pairs\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5752, __PRETTY_FUNCTION__))
;
5753 while (Size--) {
5754 unsigned DiagID = Record[Idx++];
5755 DiagnosticMapping NewMapping =
5756 DiagnosticMapping::deserialize(Record[Idx++]);
5757 if (!NewMapping.isPragma() && !IncludeNonPragmaStates)
5758 continue;
5759
5760 DiagnosticMapping &Mapping = NewState->getOrAddMapping(DiagID);
5761
5762 // If this mapping was specified as a warning but the severity was
5763 // upgraded due to diagnostic settings, simulate the current diagnostic
5764 // settings (and use a warning).
5765 if (NewMapping.wasUpgradedFromWarning() && !Mapping.isErrorOrFatal()) {
5766 NewMapping.setSeverity(diag::Severity::Warning);
5767 NewMapping.setUpgradedFromWarning(false);
5768 }
5769
5770 Mapping = NewMapping;
5771 }
5772 return NewState;
5773 };
5774
5775 // Read the first state.
5776 DiagState *FirstState;
5777 if (F.Kind == MK_ImplicitModule) {
5778 // Implicitly-built modules are reused with different diagnostic
5779 // settings. Use the initial diagnostic state from Diag to simulate this
5780 // compilation's diagnostic settings.
5781 FirstState = Diag.DiagStatesByLoc.FirstDiagState;
5782 DiagStates.push_back(FirstState);
5783
5784 // Skip the initial diagnostic state from the serialized module.
5785 assert(Record[1] == 0 &&((Record[1] == 0 && "Invalid data, unexpected backref in initial state"
) ? static_cast<void> (0) : __assert_fail ("Record[1] == 0 && \"Invalid data, unexpected backref in initial state\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5786, __PRETTY_FUNCTION__))
5786 "Invalid data, unexpected backref in initial state")((Record[1] == 0 && "Invalid data, unexpected backref in initial state"
) ? static_cast<void> (0) : __assert_fail ("Record[1] == 0 && \"Invalid data, unexpected backref in initial state\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5786, __PRETTY_FUNCTION__))
;
5787 Idx = 3 + Record[2] * 2;
5788 assert(Idx < Record.size() &&((Idx < Record.size() && "Invalid data, not enough state change pairs in initial state"
) ? static_cast<void> (0) : __assert_fail ("Idx < Record.size() && \"Invalid data, not enough state change pairs in initial state\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5789, __PRETTY_FUNCTION__))
5789 "Invalid data, not enough state change pairs in initial state")((Idx < Record.size() && "Invalid data, not enough state change pairs in initial state"
) ? static_cast<void> (0) : __assert_fail ("Idx < Record.size() && \"Invalid data, not enough state change pairs in initial state\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5789, __PRETTY_FUNCTION__))
;
5790 } else if (F.isModule()) {
5791 // For an explicit module, preserve the flags from the module build
5792 // command line (-w, -Weverything, -Werror, ...) along with any explicit
5793 // -Wblah flags.
5794 unsigned Flags = Record[Idx++];
5795 DiagState Initial;
5796 Initial.SuppressSystemWarnings = Flags & 1; Flags >>= 1;
5797 Initial.ErrorsAsFatal = Flags & 1; Flags >>= 1;
5798 Initial.WarningsAsErrors = Flags & 1; Flags >>= 1;
5799 Initial.EnableAllWarnings = Flags & 1; Flags >>= 1;
5800 Initial.IgnoreAllWarnings = Flags & 1; Flags >>= 1;
5801 Initial.ExtBehavior = (diag::Severity)Flags;
5802 FirstState = ReadDiagState(Initial, SourceLocation(), true);
5803
5804 assert(F.OriginalSourceFileID.isValid())((F.OriginalSourceFileID.isValid()) ? static_cast<void>
(0) : __assert_fail ("F.OriginalSourceFileID.isValid()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5804, __PRETTY_FUNCTION__))
;
5805
5806 // Set up the root buffer of the module to start with the initial
5807 // diagnostic state of the module itself, to cover files that contain no
5808 // explicit transitions (for which we did not serialize anything).
5809 Diag.DiagStatesByLoc.Files[F.OriginalSourceFileID]
5810 .StateTransitions.push_back({FirstState, 0});
5811 } else {
5812 // For prefix ASTs, start with whatever the user configured on the
5813 // command line.
5814 Idx++; // Skip flags.
5815 FirstState = ReadDiagState(*Diag.DiagStatesByLoc.CurDiagState,
5816 SourceLocation(), false);
5817 }
5818
5819 // Read the state transitions.
5820 unsigned NumLocations = Record[Idx++];
5821 while (NumLocations--) {
5822 assert(Idx < Record.size() &&((Idx < Record.size() && "Invalid data, missing pragma diagnostic states"
) ? static_cast<void> (0) : __assert_fail ("Idx < Record.size() && \"Invalid data, missing pragma diagnostic states\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5823, __PRETTY_FUNCTION__))
5823 "Invalid data, missing pragma diagnostic states")((Idx < Record.size() && "Invalid data, missing pragma diagnostic states"
) ? static_cast<void> (0) : __assert_fail ("Idx < Record.size() && \"Invalid data, missing pragma diagnostic states\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5823, __PRETTY_FUNCTION__))
;
5824 SourceLocation Loc = ReadSourceLocation(F, Record[Idx++]);
5825 auto IDAndOffset = SourceMgr.getDecomposedLoc(Loc);
5826 assert(IDAndOffset.first.isValid() && "invalid FileID for transition")((IDAndOffset.first.isValid() && "invalid FileID for transition"
) ? static_cast<void> (0) : __assert_fail ("IDAndOffset.first.isValid() && \"invalid FileID for transition\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5826, __PRETTY_FUNCTION__))
;
5827 assert(IDAndOffset.second == 0 && "not a start location for a FileID")((IDAndOffset.second == 0 && "not a start location for a FileID"
) ? static_cast<void> (0) : __assert_fail ("IDAndOffset.second == 0 && \"not a start location for a FileID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5827, __PRETTY_FUNCTION__))
;
5828 unsigned Transitions = Record[Idx++];
5829
5830 // Note that we don't need to set up Parent/ParentOffset here, because
5831 // we won't be changing the diagnostic state within imported FileIDs
5832 // (other than perhaps appending to the main source file, which has no
5833 // parent).
5834 auto &F = Diag.DiagStatesByLoc.Files[IDAndOffset.first];
5835 F.StateTransitions.reserve(F.StateTransitions.size() + Transitions);
5836 for (unsigned I = 0; I != Transitions; ++I) {
5837 unsigned Offset = Record[Idx++];
5838 auto *State =
5839 ReadDiagState(*FirstState, Loc.getLocWithOffset(Offset), false);
5840 F.StateTransitions.push_back({State, Offset});
5841 }
5842 }
5843
5844 // Read the final state.
5845 assert(Idx < Record.size() &&((Idx < Record.size() && "Invalid data, missing final pragma diagnostic state"
) ? static_cast<void> (0) : __assert_fail ("Idx < Record.size() && \"Invalid data, missing final pragma diagnostic state\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5846, __PRETTY_FUNCTION__))
5846 "Invalid data, missing final pragma diagnostic state")((Idx < Record.size() && "Invalid data, missing final pragma diagnostic state"
) ? static_cast<void> (0) : __assert_fail ("Idx < Record.size() && \"Invalid data, missing final pragma diagnostic state\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5846, __PRETTY_FUNCTION__))
;
5847 SourceLocation CurStateLoc =
5848 ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5849 auto *CurState = ReadDiagState(*FirstState, CurStateLoc, false);
5850
5851 if (!F.isModule()) {
5852 Diag.DiagStatesByLoc.CurDiagState = CurState;
5853 Diag.DiagStatesByLoc.CurDiagStateLoc = CurStateLoc;
5854
5855 // Preserve the property that the imaginary root file describes the
5856 // current state.
5857 FileID NullFile;
5858 auto &T = Diag.DiagStatesByLoc.Files[NullFile].StateTransitions;
5859 if (T.empty())
5860 T.push_back({CurState, 0});
5861 else
5862 T[0].State = CurState;
5863 }
5864
5865 // Don't try to read these mappings again.
5866 Record.clear();
5867 }
5868}
5869
5870/// Get the correct cursor and offset for loading a type.
5871ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5872 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5873 assert(I != GlobalTypeMap.end() && "Corrupted global type map")((I != GlobalTypeMap.end() && "Corrupted global type map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalTypeMap.end() && \"Corrupted global type map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5873, __PRETTY_FUNCTION__))
;
5874 ModuleFile *M = I->second;
5875 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5876}
5877
5878/// Read and return the type with the given index..
5879///
5880/// The index is the type ID, shifted and minus the number of predefs. This
5881/// routine actually reads the record corresponding to the type at the given
5882/// location. It is a helper routine for GetType, which deals with reading type
5883/// IDs.
5884QualType ASTReader::readTypeRecord(unsigned Index) {
5885 assert(ContextObj && "reading type with no AST context")((ContextObj && "reading type with no AST context") ?
static_cast<void> (0) : __assert_fail ("ContextObj && \"reading type with no AST context\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 5885, __PRETTY_FUNCTION__))
;
5886 ASTContext &Context = *ContextObj;
5887 RecordLocation Loc = TypeCursorForIndex(Index);
5888 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5889
5890 // Keep track of where we are in the stream, then jump back there
5891 // after reading this type.
5892 SavedStreamPosition SavedPosition(DeclsCursor);
5893
5894 ReadingKindTracker ReadingKind(Read_Type, *this);
5895
5896 // Note that we are loading a type record.
5897 Deserializing AType(this);
5898
5899 unsigned Idx = 0;
5900 DeclsCursor.JumpToBit(Loc.Offset);
5901 RecordData Record;
5902 unsigned Code = DeclsCursor.ReadCode();
5903 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5904 case TYPE_EXT_QUAL: {
5905 if (Record.size() != 2) {
5906 Error("Incorrect encoding of extended qualifier type");
5907 return QualType();
5908 }
5909 QualType Base = readType(*Loc.F, Record, Idx);
5910 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5911 return Context.getQualifiedType(Base, Quals);
5912 }
5913
5914 case TYPE_COMPLEX: {
5915 if (Record.size() != 1) {
5916 Error("Incorrect encoding of complex type");
5917 return QualType();
5918 }
5919 QualType ElemType = readType(*Loc.F, Record, Idx);
5920 return Context.getComplexType(ElemType);
5921 }
5922
5923 case TYPE_POINTER: {
5924 if (Record.size() != 1) {
5925 Error("Incorrect encoding of pointer type");
5926 return QualType();
5927 }
5928 QualType PointeeType = readType(*Loc.F, Record, Idx);
5929 return Context.getPointerType(PointeeType);
5930 }
5931
5932 case TYPE_DECAYED: {
5933 if (Record.size() != 1) {
5934 Error("Incorrect encoding of decayed type");
5935 return QualType();
5936 }
5937 QualType OriginalType = readType(*Loc.F, Record, Idx);
5938 QualType DT = Context.getAdjustedParameterType(OriginalType);
5939 if (!isa<DecayedType>(DT))
5940 Error("Decayed type does not decay");
5941 return DT;
5942 }
5943
5944 case TYPE_ADJUSTED: {
5945 if (Record.size() != 2) {
5946 Error("Incorrect encoding of adjusted type");
5947 return QualType();
5948 }
5949 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5950 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5951 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5952 }
5953
5954 case TYPE_BLOCK_POINTER: {
5955 if (Record.size() != 1) {
5956 Error("Incorrect encoding of block pointer type");
5957 return QualType();
5958 }
5959 QualType PointeeType = readType(*Loc.F, Record, Idx);
5960 return Context.getBlockPointerType(PointeeType);
5961 }
5962
5963 case TYPE_LVALUE_REFERENCE: {
5964 if (Record.size() != 2) {
5965 Error("Incorrect encoding of lvalue reference type");
5966 return QualType();
5967 }
5968 QualType PointeeType = readType(*Loc.F, Record, Idx);
5969 return Context.getLValueReferenceType(PointeeType, Record[1]);
5970 }
5971
5972 case TYPE_RVALUE_REFERENCE: {
5973 if (Record.size() != 1) {
5974 Error("Incorrect encoding of rvalue reference type");
5975 return QualType();
5976 }
5977 QualType PointeeType = readType(*Loc.F, Record, Idx);
5978 return Context.getRValueReferenceType(PointeeType);
5979 }
5980
5981 case TYPE_MEMBER_POINTER: {
5982 if (Record.size() != 2) {
5983 Error("Incorrect encoding of member pointer type");
5984 return QualType();
5985 }
5986 QualType PointeeType = readType(*Loc.F, Record, Idx);
5987 QualType ClassType = readType(*Loc.F, Record, Idx);
5988 if (PointeeType.isNull() || ClassType.isNull())
5989 return QualType();
5990
5991 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5992 }
5993
5994 case TYPE_CONSTANT_ARRAY: {
5995 QualType ElementType = readType(*Loc.F, Record, Idx);
5996 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5997 unsigned IndexTypeQuals = Record[2];
5998 unsigned Idx = 3;
5999 llvm::APInt Size = ReadAPInt(Record, Idx);
6000 return Context.getConstantArrayType(ElementType, Size,
6001 ASM, IndexTypeQuals);
6002 }
6003
6004 case TYPE_INCOMPLETE_ARRAY: {
6005 QualType ElementType = readType(*Loc.F, Record, Idx);
6006 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
6007 unsigned IndexTypeQuals = Record[2];
6008 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
6009 }
6010
6011 case TYPE_VARIABLE_ARRAY: {
6012 QualType ElementType = readType(*Loc.F, Record, Idx);
6013 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
6014 unsigned IndexTypeQuals = Record[2];
6015 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
6016 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
6017 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
6018 ASM, IndexTypeQuals,
6019 SourceRange(LBLoc, RBLoc));
6020 }
6021
6022 case TYPE_VECTOR: {
6023 if (Record.size() != 3) {
6024 Error("incorrect encoding of vector type in AST file");
6025 return QualType();
6026 }
6027
6028 QualType ElementType = readType(*Loc.F, Record, Idx);
6029 unsigned NumElements = Record[1];
6030 unsigned VecKind = Record[2];
6031 return Context.getVectorType(ElementType, NumElements,
6032 (VectorType::VectorKind)VecKind);
6033 }
6034
6035 case TYPE_EXT_VECTOR: {
6036 if (Record.size() != 3) {
6037 Error("incorrect encoding of extended vector type in AST file");
6038 return QualType();
6039 }
6040
6041 QualType ElementType = readType(*Loc.F, Record, Idx);
6042 unsigned NumElements = Record[1];
6043 return Context.getExtVectorType(ElementType, NumElements);
6044 }
6045
6046 case TYPE_FUNCTION_NO_PROTO: {
6047 if (Record.size() != 8) {
6048 Error("incorrect encoding of no-proto function type");
6049 return QualType();
6050 }
6051 QualType ResultType = readType(*Loc.F, Record, Idx);
6052 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
6053 (CallingConv)Record[4], Record[5], Record[6],
6054 Record[7]);
6055 return Context.getFunctionNoProtoType(ResultType, Info);
6056 }
6057
6058 case TYPE_FUNCTION_PROTO: {
6059 QualType ResultType = readType(*Loc.F, Record, Idx);
6060
6061 FunctionProtoType::ExtProtoInfo EPI;
6062 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
6063 /*hasregparm*/ Record[2],
6064 /*regparm*/ Record[3],
6065 static_cast<CallingConv>(Record[4]),
6066 /*produces*/ Record[5],
6067 /*nocallersavedregs*/ Record[6],
6068 /*nocfcheck*/ Record[7]);
6069
6070 unsigned Idx = 8;
6071
6072 EPI.Variadic = Record[Idx++];
6073 EPI.HasTrailingReturn = Record[Idx++];
6074 EPI.TypeQuals = Qualifiers::fromOpaqueValue(Record[Idx++]);
6075 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
6076 SmallVector<QualType, 8> ExceptionStorage;
6077 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
6078
6079 unsigned NumParams = Record[Idx++];
6080 SmallVector<QualType, 16> ParamTypes;
6081 for (unsigned I = 0; I != NumParams; ++I)
6082 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
6083
6084 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
6085 if (Idx != Record.size()) {
6086 for (unsigned I = 0; I != NumParams; ++I)
6087 ExtParameterInfos.push_back(
6088 FunctionProtoType::ExtParameterInfo
6089 ::getFromOpaqueValue(Record[Idx++]));
6090 EPI.ExtParameterInfos = ExtParameterInfos.data();
6091 }
6092
6093 assert(Idx == Record.size())((Idx == Record.size()) ? static_cast<void> (0) : __assert_fail
("Idx == Record.size()", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 6093, __PRETTY_FUNCTION__))
;
6094
6095 return Context.getFunctionType(ResultType, ParamTypes, EPI);
6096 }
6097
6098 case TYPE_UNRESOLVED_USING: {
6099 unsigned Idx = 0;
6100 return Context.getTypeDeclType(
6101 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
6102 }
6103
6104 case TYPE_TYPEDEF: {
6105 if (Record.size() != 2) {
6106 Error("incorrect encoding of typedef type");
6107 return QualType();
6108 }
6109 unsigned Idx = 0;
6110 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
6111 QualType Canonical = readType(*Loc.F, Record, Idx);
6112 if (!Canonical.isNull())
6113 Canonical = Context.getCanonicalType(Canonical);
6114 return Context.getTypedefType(Decl, Canonical);
6115 }
6116
6117 case TYPE_TYPEOF_EXPR:
6118 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
6119
6120 case TYPE_TYPEOF: {
6121 if (Record.size() != 1) {
6122 Error("incorrect encoding of typeof(type) in AST file");
6123 return QualType();
6124 }
6125 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6126 return Context.getTypeOfType(UnderlyingType);
6127 }
6128
6129 case TYPE_DECLTYPE: {
6130 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6131 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
6132 }
6133
6134 case TYPE_UNARY_TRANSFORM: {
6135 QualType BaseType = readType(*Loc.F, Record, Idx);
6136 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
6137 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
6138 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
6139 }
6140
6141 case TYPE_AUTO: {
6142 QualType Deduced = readType(*Loc.F, Record, Idx);
6143 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
6144 bool IsDependent = false, IsPack = false;
6145 if (Deduced.isNull()) {
6146 IsDependent = Record[Idx] > 0;
6147 IsPack = Record[Idx] > 1;
6148 ++Idx;
6149 }
6150 return Context.getAutoType(Deduced, Keyword, IsDependent, IsPack);
6151 }
6152
6153 case TYPE_DEDUCED_TEMPLATE_SPECIALIZATION: {
6154 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6155 QualType Deduced = readType(*Loc.F, Record, Idx);
6156 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
6157 return Context.getDeducedTemplateSpecializationType(Name, Deduced,
6158 IsDependent);
6159 }
6160
6161 case TYPE_RECORD: {
6162 if (Record.size() != 2) {
6163 Error("incorrect encoding of record type");
6164 return QualType();
6165 }
6166 unsigned Idx = 0;
6167 bool IsDependent = Record[Idx++];
6168 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
6169 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
6170 QualType T = Context.getRecordType(RD);
6171 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6172 return T;
6173 }
6174
6175 case TYPE_ENUM: {
6176 if (Record.size() != 2) {
6177 Error("incorrect encoding of enum type");
6178 return QualType();
6179 }
6180 unsigned Idx = 0;
6181 bool IsDependent = Record[Idx++];
6182 QualType T
6183 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
6184 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6185 return T;
6186 }
6187
6188 case TYPE_ATTRIBUTED: {
6189 if (Record.size() != 3) {
6190 Error("incorrect encoding of attributed type");
6191 return QualType();
6192 }
6193 QualType modifiedType = readType(*Loc.F, Record, Idx);
6194 QualType equivalentType = readType(*Loc.F, Record, Idx);
6195 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
6196 return Context.getAttributedType(kind, modifiedType, equivalentType);
6197 }
6198
6199 case TYPE_PAREN: {
6200 if (Record.size() != 1) {
6201 Error("incorrect encoding of paren type");
6202 return QualType();
6203 }
6204 QualType InnerType = readType(*Loc.F, Record, Idx);
6205 return Context.getParenType(InnerType);
6206 }
6207
6208 case TYPE_MACRO_QUALIFIED: {
6209 if (Record.size() != 2) {
6210 Error("incorrect encoding of macro defined type");
6211 return QualType();
6212 }
6213 QualType UnderlyingTy = readType(*Loc.F, Record, Idx);
6214 IdentifierInfo *MacroII = GetIdentifierInfo(*Loc.F, Record, Idx);
6215 return Context.getMacroQualifiedType(UnderlyingTy, MacroII);
6216 }
6217
6218 case TYPE_PACK_EXPANSION: {
6219 if (Record.size() != 2) {
6220 Error("incorrect encoding of pack expansion type");
6221 return QualType();
6222 }
6223 QualType Pattern = readType(*Loc.F, Record, Idx);
6224 if (Pattern.isNull())
6225 return QualType();
6226 Optional<unsigned> NumExpansions;
6227 if (Record[1])
6228 NumExpansions = Record[1] - 1;
6229 return Context.getPackExpansionType(Pattern, NumExpansions);
6230 }
6231
6232 case TYPE_ELABORATED: {
6233 unsigned Idx = 0;
6234 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6235 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6236 QualType NamedType = readType(*Loc.F, Record, Idx);
6237 TagDecl *OwnedTagDecl = ReadDeclAs<TagDecl>(*Loc.F, Record, Idx);
6238 return Context.getElaboratedType(Keyword, NNS, NamedType, OwnedTagDecl);
6239 }
6240
6241 case TYPE_OBJC_INTERFACE: {
6242 unsigned Idx = 0;
6243 ObjCInterfaceDecl *ItfD
6244 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
6245 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
6246 }
6247
6248 case TYPE_OBJC_TYPE_PARAM: {
6249 unsigned Idx = 0;
6250 ObjCTypeParamDecl *Decl
6251 = ReadDeclAs<ObjCTypeParamDecl>(*Loc.F, Record, Idx);
6252 unsigned NumProtos = Record[Idx++];
6253 SmallVector<ObjCProtocolDecl*, 4> Protos;
6254 for (unsigned I = 0; I != NumProtos; ++I)
6255 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6256 return Context.getObjCTypeParamType(Decl, Protos);
6257 }
6258
6259 case TYPE_OBJC_OBJECT: {
6260 unsigned Idx = 0;
6261 QualType Base = readType(*Loc.F, Record, Idx);
6262 unsigned NumTypeArgs = Record[Idx++];
6263 SmallVector<QualType, 4> TypeArgs;
6264 for (unsigned I = 0; I != NumTypeArgs; ++I)
6265 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
6266 unsigned NumProtos = Record[Idx++];
6267 SmallVector<ObjCProtocolDecl*, 4> Protos;
6268 for (unsigned I = 0; I != NumProtos; ++I)
6269 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
6270 bool IsKindOf = Record[Idx++];
6271 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
6272 }
6273
6274 case TYPE_OBJC_OBJECT_POINTER: {
6275 unsigned Idx = 0;
6276 QualType Pointee = readType(*Loc.F, Record, Idx);
6277 return Context.getObjCObjectPointerType(Pointee);
6278 }
6279
6280 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
6281 unsigned Idx = 0;
6282 QualType Parm = readType(*Loc.F, Record, Idx);
6283 QualType Replacement = readType(*Loc.F, Record, Idx);
6284 return Context.getSubstTemplateTypeParmType(
6285 cast<TemplateTypeParmType>(Parm),
6286 Context.getCanonicalType(Replacement));
6287 }
6288
6289 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
6290 unsigned Idx = 0;
6291 QualType Parm = readType(*Loc.F, Record, Idx);
6292 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
6293 return Context.getSubstTemplateTypeParmPackType(
6294 cast<TemplateTypeParmType>(Parm),
6295 ArgPack);
6296 }
6297
6298 case TYPE_INJECTED_CLASS_NAME: {
6299 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
6300 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
6301 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
6302 // for AST reading, too much interdependencies.
6303 const Type *T = nullptr;
6304 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
6305 if (const Type *Existing = DI->getTypeForDecl()) {
6306 T = Existing;
6307 break;
6308 }
6309 }
6310 if (!T) {
6311 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
6312 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
6313 DI->setTypeForDecl(T);
6314 }
6315 return QualType(T, 0);
6316 }
6317
6318 case TYPE_TEMPLATE_TYPE_PARM: {
6319 unsigned Idx = 0;
6320 unsigned Depth = Record[Idx++];
6321 unsigned Index = Record[Idx++];
6322 bool Pack = Record[Idx++];
6323 TemplateTypeParmDecl *D
6324 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
6325 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
6326 }
6327
6328 case TYPE_DEPENDENT_NAME: {
6329 unsigned Idx = 0;
6330 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6331 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6332 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6333 QualType Canon = readType(*Loc.F, Record, Idx);
6334 if (!Canon.isNull())
6335 Canon = Context.getCanonicalType(Canon);
6336 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
6337 }
6338
6339 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
6340 unsigned Idx = 0;
6341 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
6342 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
6343 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
6344 unsigned NumArgs = Record[Idx++];
6345 SmallVector<TemplateArgument, 8> Args;
6346 Args.reserve(NumArgs);
6347 while (NumArgs--)
6348 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
6349 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
6350 Args);
6351 }
6352
6353 case TYPE_DEPENDENT_SIZED_ARRAY: {
6354 unsigned Idx = 0;
6355
6356 // ArrayType
6357 QualType ElementType = readType(*Loc.F, Record, Idx);
6358 ArrayType::ArraySizeModifier ASM
6359 = (ArrayType::ArraySizeModifier)Record[Idx++];
6360 unsigned IndexTypeQuals = Record[Idx++];
6361
6362 // DependentSizedArrayType
6363 Expr *NumElts = ReadExpr(*Loc.F);
6364 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
6365
6366 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
6367 IndexTypeQuals, Brackets);
6368 }
6369
6370 case TYPE_TEMPLATE_SPECIALIZATION: {
6371 unsigned Idx = 0;
6372 bool IsDependent = Record[Idx++];
6373 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
6374 SmallVector<TemplateArgument, 8> Args;
6375 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
6376 QualType Underlying = readType(*Loc.F, Record, Idx);
6377 QualType T;
6378 if (Underlying.isNull())
6379 T = Context.getCanonicalTemplateSpecializationType(Name, Args);
6380 else
6381 T = Context.getTemplateSpecializationType(Name, Args, Underlying);
6382 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
6383 return T;
6384 }
6385
6386 case TYPE_ATOMIC: {
6387 if (Record.size() != 1) {
6388 Error("Incorrect encoding of atomic type");
6389 return QualType();
6390 }
6391 QualType ValueType = readType(*Loc.F, Record, Idx);
6392 return Context.getAtomicType(ValueType);
6393 }
6394
6395 case TYPE_PIPE: {
6396 if (Record.size() != 2) {
6397 Error("Incorrect encoding of pipe type");
6398 return QualType();
6399 }
6400
6401 // Reading the pipe element type.
6402 QualType ElementType = readType(*Loc.F, Record, Idx);
6403 unsigned ReadOnly = Record[1];
6404 return Context.getPipeType(ElementType, ReadOnly);
6405 }
6406
6407 case TYPE_DEPENDENT_SIZED_VECTOR: {
6408 unsigned Idx = 0;
6409 QualType ElementType = readType(*Loc.F, Record, Idx);
6410 Expr *SizeExpr = ReadExpr(*Loc.F);
6411 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6412 unsigned VecKind = Record[Idx];
6413
6414 return Context.getDependentVectorType(ElementType, SizeExpr, AttrLoc,
6415 (VectorType::VectorKind)VecKind);
6416 }
6417
6418 case TYPE_DEPENDENT_SIZED_EXT_VECTOR: {
6419 unsigned Idx = 0;
6420
6421 // DependentSizedExtVectorType
6422 QualType ElementType = readType(*Loc.F, Record, Idx);
6423 Expr *SizeExpr = ReadExpr(*Loc.F);
6424 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6425
6426 return Context.getDependentSizedExtVectorType(ElementType, SizeExpr,
6427 AttrLoc);
6428 }
6429
6430 case TYPE_DEPENDENT_ADDRESS_SPACE: {
6431 unsigned Idx = 0;
6432
6433 // DependentAddressSpaceType
6434 QualType PointeeType = readType(*Loc.F, Record, Idx);
6435 Expr *AddrSpaceExpr = ReadExpr(*Loc.F);
6436 SourceLocation AttrLoc = ReadSourceLocation(*Loc.F, Record, Idx);
6437
6438 return Context.getDependentAddressSpaceType(PointeeType, AddrSpaceExpr,
6439 AttrLoc);
6440 }
6441 }
6442 llvm_unreachable("Invalid TypeCode!")::llvm::llvm_unreachable_internal("Invalid TypeCode!", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 6442)
;
6443}
6444
6445void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
6446 SmallVectorImpl<QualType> &Exceptions,
6447 FunctionProtoType::ExceptionSpecInfo &ESI,
6448 const RecordData &Record, unsigned &Idx) {
6449 ExceptionSpecificationType EST =
6450 static_cast<ExceptionSpecificationType>(Record[Idx++]);
6451 ESI.Type = EST;
6452 if (EST == EST_Dynamic) {
6453 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6454 Exceptions.push_back(readType(ModuleFile, Record, Idx));
6455 ESI.Exceptions = Exceptions;
6456 } else if (isComputedNoexcept(EST)) {
6457 ESI.NoexceptExpr = ReadExpr(ModuleFile);
6458 } else if (EST == EST_Uninstantiated) {
6459 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6460 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6461 } else if (EST == EST_Unevaluated) {
6462 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
6463 }
6464}
6465
6466namespace clang {
6467
6468class TypeLocReader : public TypeLocVisitor<TypeLocReader> {
6469 ModuleFile *F;
6470 ASTReader *Reader;
6471 const ASTReader::RecordData &Record;
6472 unsigned &Idx;
6473
6474 SourceLocation ReadSourceLocation() {
6475 return Reader->ReadSourceLocation(*F, Record, Idx);
6476 }
6477
6478 TypeSourceInfo *GetTypeSourceInfo() {
6479 return Reader->GetTypeSourceInfo(*F, Record, Idx);
6480 }
6481
6482 NestedNameSpecifierLoc ReadNestedNameSpecifierLoc() {
6483 return Reader->ReadNestedNameSpecifierLoc(*F, Record, Idx);
6484 }
6485
6486 Attr *ReadAttr() {
6487 return Reader->ReadAttr(*F, Record, Idx);
6488 }
6489
6490public:
6491 TypeLocReader(ModuleFile &F, ASTReader &Reader,
6492 const ASTReader::RecordData &Record, unsigned &Idx)
6493 : F(&F), Reader(&Reader), Record(Record), Idx(Idx) {}
6494
6495 // We want compile-time assurance that we've enumerated all of
6496 // these, so unfortunately we have to declare them first, then
6497 // define them out-of-line.
6498#define ABSTRACT_TYPELOC(CLASS, PARENT)
6499#define TYPELOC(CLASS, PARENT) \
6500 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
6501#include "clang/AST/TypeLocNodes.def"
6502
6503 void VisitFunctionTypeLoc(FunctionTypeLoc);
6504 void VisitArrayTypeLoc(ArrayTypeLoc);
6505};
6506
6507} // namespace clang
6508
6509void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
6510 // nothing to do
6511}
6512
6513void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
6514 TL.setBuiltinLoc(ReadSourceLocation());
6515 if (TL.needsExtraLocalData()) {
6516 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6517 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6518 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6519 TL.setModeAttr(Record[Idx++]);
6520 }
6521}
6522
6523void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
6524 TL.setNameLoc(ReadSourceLocation());
6525}
6526
6527void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
6528 TL.setStarLoc(ReadSourceLocation());
6529}
6530
6531void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
6532 // nothing to do
6533}
6534
6535void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
6536 // nothing to do
6537}
6538
6539void TypeLocReader::VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc TL) {
6540 TL.setExpansionLoc(ReadSourceLocation());
6541}
6542
6543void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
6544 TL.setCaretLoc(ReadSourceLocation());
6545}
6546
6547void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
6548 TL.setAmpLoc(ReadSourceLocation());
6549}
6550
6551void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
6552 TL.setAmpAmpLoc(ReadSourceLocation());
6553}
6554
6555void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
6556 TL.setStarLoc(ReadSourceLocation());
6557 TL.setClassTInfo(GetTypeSourceInfo());
6558}
6559
6560void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
6561 TL.setLBracketLoc(ReadSourceLocation());
6562 TL.setRBracketLoc(ReadSourceLocation());
6563 if (Record[Idx++])
6564 TL.setSizeExpr(Reader->ReadExpr(*F));
6565 else
6566 TL.setSizeExpr(nullptr);
6567}
6568
6569void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
6570 VisitArrayTypeLoc(TL);
6571}
6572
6573void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
6574 VisitArrayTypeLoc(TL);
6575}
6576
6577void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
6578 VisitArrayTypeLoc(TL);
6579}
6580
6581void TypeLocReader::VisitDependentSizedArrayTypeLoc(
6582 DependentSizedArrayTypeLoc TL) {
6583 VisitArrayTypeLoc(TL);
6584}
6585
6586void TypeLocReader::VisitDependentAddressSpaceTypeLoc(
6587 DependentAddressSpaceTypeLoc TL) {
6588
6589 TL.setAttrNameLoc(ReadSourceLocation());
6590 SourceRange range;
6591 range.setBegin(ReadSourceLocation());
6592 range.setEnd(ReadSourceLocation());
6593 TL.setAttrOperandParensRange(range);
6594 TL.setAttrExprOperand(Reader->ReadExpr(*F));
6595}
6596
6597void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
6598 DependentSizedExtVectorTypeLoc TL) {
6599 TL.setNameLoc(ReadSourceLocation());
6600}
6601
6602void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
6603 TL.setNameLoc(ReadSourceLocation());
6604}
6605
6606void TypeLocReader::VisitDependentVectorTypeLoc(
6607 DependentVectorTypeLoc TL) {
6608 TL.setNameLoc(ReadSourceLocation());
6609}
6610
6611void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
6612 TL.setNameLoc(ReadSourceLocation());
6613}
6614
6615void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
6616 TL.setLocalRangeBegin(ReadSourceLocation());
6617 TL.setLParenLoc(ReadSourceLocation());
6618 TL.setRParenLoc(ReadSourceLocation());
6619 TL.setExceptionSpecRange(SourceRange(Reader->ReadSourceLocation(*F, Record, Idx),
6620 Reader->ReadSourceLocation(*F, Record, Idx)));
6621 TL.setLocalRangeEnd(ReadSourceLocation());
6622 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
6623 TL.setParam(i, Reader->ReadDeclAs<ParmVarDecl>(*F, Record, Idx));
6624 }
6625}
6626
6627void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
6628 VisitFunctionTypeLoc(TL);
6629}
6630
6631void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
6632 VisitFunctionTypeLoc(TL);
6633}
6634
6635void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
6636 TL.setNameLoc(ReadSourceLocation());
6637}
6638
6639void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
6640 TL.setNameLoc(ReadSourceLocation());
6641}
6642
6643void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
6644 TL.setTypeofLoc(ReadSourceLocation());
6645 TL.setLParenLoc(ReadSourceLocation());
6646 TL.setRParenLoc(ReadSourceLocation());
6647}
6648
6649void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
6650 TL.setTypeofLoc(ReadSourceLocation());
6651 TL.setLParenLoc(ReadSourceLocation());
6652 TL.setRParenLoc(ReadSourceLocation());
6653 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6654}
6655
6656void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
6657 TL.setNameLoc(ReadSourceLocation());
6658}
6659
6660void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
6661 TL.setKWLoc(ReadSourceLocation());
6662 TL.setLParenLoc(ReadSourceLocation());
6663 TL.setRParenLoc(ReadSourceLocation());
6664 TL.setUnderlyingTInfo(GetTypeSourceInfo());
6665}
6666
6667void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
6668 TL.setNameLoc(ReadSourceLocation());
6669}
6670
6671void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
6672 DeducedTemplateSpecializationTypeLoc TL) {
6673 TL.setTemplateNameLoc(ReadSourceLocation());
6674}
6675
6676void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
6677 TL.setNameLoc(ReadSourceLocation());
6678}
6679
6680void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
6681 TL.setNameLoc(ReadSourceLocation());
6682}
6683
6684void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
6685 TL.setAttr(ReadAttr());
6686}
6687
6688void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
6689 TL.setNameLoc(ReadSourceLocation());
6690}
6691
6692void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
6693 SubstTemplateTypeParmTypeLoc TL) {
6694 TL.setNameLoc(ReadSourceLocation());
6695}
6696
6697void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
6698 SubstTemplateTypeParmPackTypeLoc TL) {
6699 TL.setNameLoc(ReadSourceLocation());
6700}
6701
6702void TypeLocReader::VisitTemplateSpecializationTypeLoc(
6703 TemplateSpecializationTypeLoc TL) {
6704 TL.setTemplateKeywordLoc(ReadSourceLocation());
6705 TL.setTemplateNameLoc(ReadSourceLocation());
6706 TL.setLAngleLoc(ReadSourceLocation());
6707 TL.setRAngleLoc(ReadSourceLocation());
6708 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
6709 TL.setArgLocInfo(
6710 i,
6711 Reader->GetTemplateArgumentLocInfo(
6712 *F, TL.getTypePtr()->getArg(i).getKind(), Record, Idx));
6713}
6714
6715void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
6716 TL.setLParenLoc(ReadSourceLocation());
6717 TL.setRParenLoc(ReadSourceLocation());
6718}
6719
6720void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
6721 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6722 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6723}
6724
6725void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
6726 TL.setNameLoc(ReadSourceLocation());
6727}
6728
6729void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
6730 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6731 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6732 TL.setNameLoc(ReadSourceLocation());
6733}
6734
6735void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
6736 DependentTemplateSpecializationTypeLoc TL) {
6737 TL.setElaboratedKeywordLoc(ReadSourceLocation());
6738 TL.setQualifierLoc(ReadNestedNameSpecifierLoc());
6739 TL.setTemplateKeywordLoc(ReadSourceLocation());
6740 TL.setTemplateNameLoc(ReadSourceLocation());
6741 TL.setLAngleLoc(ReadSourceLocation());
6742 TL.setRAngleLoc(ReadSourceLocation());
6743 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
6744 TL.setArgLocInfo(
6745 I,
6746 Reader->GetTemplateArgumentLocInfo(
6747 *F, TL.getTypePtr()->getArg(I).getKind(), Record, Idx));
6748}
6749
6750void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
6751 TL.setEllipsisLoc(ReadSourceLocation());
6752}
6753
6754void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
6755 TL.setNameLoc(ReadSourceLocation());
6756}
6757
6758void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
6759 if (TL.getNumProtocols()) {
6760 TL.setProtocolLAngleLoc(ReadSourceLocation());
6761 TL.setProtocolRAngleLoc(ReadSourceLocation());
6762 }
6763 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6764 TL.setProtocolLoc(i, ReadSourceLocation());
6765}
6766
6767void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
6768 TL.setHasBaseTypeAsWritten(Record[Idx++]);
6769 TL.setTypeArgsLAngleLoc(ReadSourceLocation());
6770 TL.setTypeArgsRAngleLoc(ReadSourceLocation());
6771 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
6772 TL.setTypeArgTInfo(i, GetTypeSourceInfo());
6773 TL.setProtocolLAngleLoc(ReadSourceLocation());
6774 TL.setProtocolRAngleLoc(ReadSourceLocation());
6775 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
6776 TL.setProtocolLoc(i, ReadSourceLocation());
6777}
6778
6779void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
6780 TL.setStarLoc(ReadSourceLocation());
6781}
6782
6783void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
6784 TL.setKWLoc(ReadSourceLocation());
6785 TL.setLParenLoc(ReadSourceLocation());
6786 TL.setRParenLoc(ReadSourceLocation());
6787}
6788
6789void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
6790 TL.setKWLoc(ReadSourceLocation());
6791}
6792
6793void ASTReader::ReadTypeLoc(ModuleFile &F, const ASTReader::RecordData &Record,
6794 unsigned &Idx, TypeLoc TL) {
6795 TypeLocReader TLR(F, *this, Record, Idx);
6796 for (; !TL.isNull(); TL = TL.getNextTypeLoc())
6797 TLR.Visit(TL);
6798}
6799
6800TypeSourceInfo *
6801ASTReader::GetTypeSourceInfo(ModuleFile &F, const ASTReader::RecordData &Record,
6802 unsigned &Idx) {
6803 QualType InfoTy = readType(F, Record, Idx);
6804 if (InfoTy.isNull())
6805 return nullptr;
6806
6807 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
6808 ReadTypeLoc(F, Record, Idx, TInfo->getTypeLoc());
6809 return TInfo;
6810}
6811
6812QualType ASTReader::GetType(TypeID ID) {
6813 assert(ContextObj && "reading type with no AST context")((ContextObj && "reading type with no AST context") ?
static_cast<void> (0) : __assert_fail ("ContextObj && \"reading type with no AST context\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 6813, __PRETTY_FUNCTION__))
;
6814 ASTContext &Context = *ContextObj;
6815
6816 unsigned FastQuals = ID & Qualifiers::FastMask;
6817 unsigned Index = ID >> Qualifiers::FastWidth;
6818
6819 if (Index < NUM_PREDEF_TYPE_IDS) {
6820 QualType T;
6821 switch ((PredefinedTypeIDs)Index) {
6822 case PREDEF_TYPE_NULL_ID:
6823 return QualType();
6824 case PREDEF_TYPE_VOID_ID:
6825 T = Context.VoidTy;
6826 break;
6827 case PREDEF_TYPE_BOOL_ID:
6828 T = Context.BoolTy;
6829 break;
6830 case PREDEF_TYPE_CHAR_U_ID:
6831 case PREDEF_TYPE_CHAR_S_ID:
6832 // FIXME: Check that the signedness of CharTy is correct!
6833 T = Context.CharTy;
6834 break;
6835 case PREDEF_TYPE_UCHAR_ID:
6836 T = Context.UnsignedCharTy;
6837 break;
6838 case PREDEF_TYPE_USHORT_ID:
6839 T = Context.UnsignedShortTy;
6840 break;
6841 case PREDEF_TYPE_UINT_ID:
6842 T = Context.UnsignedIntTy;
6843 break;
6844 case PREDEF_TYPE_ULONG_ID:
6845 T = Context.UnsignedLongTy;
6846 break;
6847 case PREDEF_TYPE_ULONGLONG_ID:
6848 T = Context.UnsignedLongLongTy;
6849 break;
6850 case PREDEF_TYPE_UINT128_ID:
6851 T = Context.UnsignedInt128Ty;
6852 break;
6853 case PREDEF_TYPE_SCHAR_ID:
6854 T = Context.SignedCharTy;
6855 break;
6856 case PREDEF_TYPE_WCHAR_ID:
6857 T = Context.WCharTy;
6858 break;
6859 case PREDEF_TYPE_SHORT_ID:
6860 T = Context.ShortTy;
6861 break;
6862 case PREDEF_TYPE_INT_ID:
6863 T = Context.IntTy;
6864 break;
6865 case PREDEF_TYPE_LONG_ID:
6866 T = Context.LongTy;
6867 break;
6868 case PREDEF_TYPE_LONGLONG_ID:
6869 T = Context.LongLongTy;
6870 break;
6871 case PREDEF_TYPE_INT128_ID:
6872 T = Context.Int128Ty;
6873 break;
6874 case PREDEF_TYPE_HALF_ID:
6875 T = Context.HalfTy;
6876 break;
6877 case PREDEF_TYPE_FLOAT_ID:
6878 T = Context.FloatTy;
6879 break;
6880 case PREDEF_TYPE_DOUBLE_ID:
6881 T = Context.DoubleTy;
6882 break;
6883 case PREDEF_TYPE_LONGDOUBLE_ID:
6884 T = Context.LongDoubleTy;
6885 break;
6886 case PREDEF_TYPE_SHORT_ACCUM_ID:
6887 T = Context.ShortAccumTy;
6888 break;
6889 case PREDEF_TYPE_ACCUM_ID:
6890 T = Context.AccumTy;
6891 break;
6892 case PREDEF_TYPE_LONG_ACCUM_ID:
6893 T = Context.LongAccumTy;
6894 break;
6895 case PREDEF_TYPE_USHORT_ACCUM_ID:
6896 T = Context.UnsignedShortAccumTy;
6897 break;
6898 case PREDEF_TYPE_UACCUM_ID:
6899 T = Context.UnsignedAccumTy;
6900 break;
6901 case PREDEF_TYPE_ULONG_ACCUM_ID:
6902 T = Context.UnsignedLongAccumTy;
6903 break;
6904 case PREDEF_TYPE_SHORT_FRACT_ID:
6905 T = Context.ShortFractTy;
6906 break;
6907 case PREDEF_TYPE_FRACT_ID:
6908 T = Context.FractTy;
6909 break;
6910 case PREDEF_TYPE_LONG_FRACT_ID:
6911 T = Context.LongFractTy;
6912 break;
6913 case PREDEF_TYPE_USHORT_FRACT_ID:
6914 T = Context.UnsignedShortFractTy;
6915 break;
6916 case PREDEF_TYPE_UFRACT_ID:
6917 T = Context.UnsignedFractTy;
6918 break;
6919 case PREDEF_TYPE_ULONG_FRACT_ID:
6920 T = Context.UnsignedLongFractTy;
6921 break;
6922 case PREDEF_TYPE_SAT_SHORT_ACCUM_ID:
6923 T = Context.SatShortAccumTy;
6924 break;
6925 case PREDEF_TYPE_SAT_ACCUM_ID:
6926 T = Context.SatAccumTy;
6927 break;
6928 case PREDEF_TYPE_SAT_LONG_ACCUM_ID:
6929 T = Context.SatLongAccumTy;
6930 break;
6931 case PREDEF_TYPE_SAT_USHORT_ACCUM_ID:
6932 T = Context.SatUnsignedShortAccumTy;
6933 break;
6934 case PREDEF_TYPE_SAT_UACCUM_ID:
6935 T = Context.SatUnsignedAccumTy;
6936 break;
6937 case PREDEF_TYPE_SAT_ULONG_ACCUM_ID:
6938 T = Context.SatUnsignedLongAccumTy;
6939 break;
6940 case PREDEF_TYPE_SAT_SHORT_FRACT_ID:
6941 T = Context.SatShortFractTy;
6942 break;
6943 case PREDEF_TYPE_SAT_FRACT_ID:
6944 T = Context.SatFractTy;
6945 break;
6946 case PREDEF_TYPE_SAT_LONG_FRACT_ID:
6947 T = Context.SatLongFractTy;
6948 break;
6949 case PREDEF_TYPE_SAT_USHORT_FRACT_ID:
6950 T = Context.SatUnsignedShortFractTy;
6951 break;
6952 case PREDEF_TYPE_SAT_UFRACT_ID:
6953 T = Context.SatUnsignedFractTy;
6954 break;
6955 case PREDEF_TYPE_SAT_ULONG_FRACT_ID:
6956 T = Context.SatUnsignedLongFractTy;
6957 break;
6958 case PREDEF_TYPE_FLOAT16_ID:
6959 T = Context.Float16Ty;
6960 break;
6961 case PREDEF_TYPE_FLOAT128_ID:
6962 T = Context.Float128Ty;
6963 break;
6964 case PREDEF_TYPE_OVERLOAD_ID:
6965 T = Context.OverloadTy;
6966 break;
6967 case PREDEF_TYPE_BOUND_MEMBER:
6968 T = Context.BoundMemberTy;
6969 break;
6970 case PREDEF_TYPE_PSEUDO_OBJECT:
6971 T = Context.PseudoObjectTy;
6972 break;
6973 case PREDEF_TYPE_DEPENDENT_ID:
6974 T = Context.DependentTy;
6975 break;
6976 case PREDEF_TYPE_UNKNOWN_ANY:
6977 T = Context.UnknownAnyTy;
6978 break;
6979 case PREDEF_TYPE_NULLPTR_ID:
6980 T = Context.NullPtrTy;
6981 break;
6982 case PREDEF_TYPE_CHAR8_ID:
6983 T = Context.Char8Ty;
6984 break;
6985 case PREDEF_TYPE_CHAR16_ID:
6986 T = Context.Char16Ty;
6987 break;
6988 case PREDEF_TYPE_CHAR32_ID:
6989 T = Context.Char32Ty;
6990 break;
6991 case PREDEF_TYPE_OBJC_ID:
6992 T = Context.ObjCBuiltinIdTy;
6993 break;
6994 case PREDEF_TYPE_OBJC_CLASS:
6995 T = Context.ObjCBuiltinClassTy;
6996 break;
6997 case PREDEF_TYPE_OBJC_SEL:
6998 T = Context.ObjCBuiltinSelTy;
6999 break;
7000#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
7001 case PREDEF_TYPE_##Id##_ID: \
7002 T = Context.SingletonId; \
7003 break;
7004#include "clang/Basic/OpenCLImageTypes.def"
7005#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
7006 case PREDEF_TYPE_##Id##_ID: \
7007 T = Context.Id##Ty; \
7008 break;
7009#include "clang/Basic/OpenCLExtensionTypes.def"
7010 case PREDEF_TYPE_SAMPLER_ID:
7011 T = Context.OCLSamplerTy;
7012 break;
7013 case PREDEF_TYPE_EVENT_ID:
7014 T = Context.OCLEventTy;
7015 break;
7016 case PREDEF_TYPE_CLK_EVENT_ID:
7017 T = Context.OCLClkEventTy;
7018 break;
7019 case PREDEF_TYPE_QUEUE_ID:
7020 T = Context.OCLQueueTy;
7021 break;
7022 case PREDEF_TYPE_RESERVE_ID_ID:
7023 T = Context.OCLReserveIDTy;
7024 break;
7025 case PREDEF_TYPE_AUTO_DEDUCT:
7026 T = Context.getAutoDeductType();
7027 break;
7028 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
7029 T = Context.getAutoRRefDeductType();
7030 break;
7031 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
7032 T = Context.ARCUnbridgedCastTy;
7033 break;
7034 case PREDEF_TYPE_BUILTIN_FN:
7035 T = Context.BuiltinFnTy;
7036 break;
7037 case PREDEF_TYPE_OMP_ARRAY_SECTION:
7038 T = Context.OMPArraySectionTy;
7039 break;
7040 }
7041
7042 assert(!T.isNull() && "Unknown predefined type")((!T.isNull() && "Unknown predefined type") ? static_cast
<void> (0) : __assert_fail ("!T.isNull() && \"Unknown predefined type\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7042, __PRETTY_FUNCTION__))
;
7043 return T.withFastQualifiers(FastQuals);
7044 }
7045
7046 Index -= NUM_PREDEF_TYPE_IDS;
7047 assert(Index < TypesLoaded.size() && "Type index out-of-range")((Index < TypesLoaded.size() && "Type index out-of-range"
) ? static_cast<void> (0) : __assert_fail ("Index < TypesLoaded.size() && \"Type index out-of-range\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7047, __PRETTY_FUNCTION__))
;
7048 if (TypesLoaded[Index].isNull()) {
7049 TypesLoaded[Index] = readTypeRecord(Index);
7050 if (TypesLoaded[Index].isNull())
7051 return QualType();
7052
7053 TypesLoaded[Index]->setFromAST();
7054 if (DeserializationListener)
7055 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
7056 TypesLoaded[Index]);
7057 }
7058
7059 return TypesLoaded[Index].withFastQualifiers(FastQuals);
7060}
7061
7062QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
7063 return GetType(getGlobalTypeID(F, LocalID));
7064}
7065
7066serialization::TypeID
7067ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
7068 unsigned FastQuals = LocalID & Qualifiers::FastMask;
7069 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
7070
7071 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
7072 return LocalID;
7073
7074 if (!F.ModuleOffsetMap.empty())
7075 ReadModuleOffsetMap(F);
7076
7077 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7078 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
7079 assert(I != F.TypeRemap.end() && "Invalid index into type index remap")((I != F.TypeRemap.end() && "Invalid index into type index remap"
) ? static_cast<void> (0) : __assert_fail ("I != F.TypeRemap.end() && \"Invalid index into type index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7079, __PRETTY_FUNCTION__))
;
7080
7081 unsigned GlobalIndex = LocalIndex + I->second;
7082 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
7083}
7084
7085TemplateArgumentLocInfo
7086ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
7087 TemplateArgument::ArgKind Kind,
7088 const RecordData &Record,
7089 unsigned &Index) {
7090 switch (Kind) {
7091 case TemplateArgument::Expression:
7092 return ReadExpr(F);
7093 case TemplateArgument::Type:
7094 return GetTypeSourceInfo(F, Record, Index);
7095 case TemplateArgument::Template: {
7096 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7097 Index);
7098 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7099 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7100 SourceLocation());
7101 }
7102 case TemplateArgument::TemplateExpansion: {
7103 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
7104 Index);
7105 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
7106 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
7107 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
7108 EllipsisLoc);
7109 }
7110 case TemplateArgument::Null:
7111 case TemplateArgument::Integral:
7112 case TemplateArgument::Declaration:
7113 case TemplateArgument::NullPtr:
7114 case TemplateArgument::Pack:
7115 // FIXME: Is this right?
7116 return TemplateArgumentLocInfo();
7117 }
7118 llvm_unreachable("unexpected template argument loc")::llvm::llvm_unreachable_internal("unexpected template argument loc"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7118)
;
7119}
7120
7121TemplateArgumentLoc
7122ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
7123 const RecordData &Record, unsigned &Index) {
7124 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
7125
7126 if (Arg.getKind() == TemplateArgument::Expression) {
7127 if (Record[Index++]) // bool InfoHasSameExpr.
7128 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
7129 }
7130 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
7131 Record, Index));
7132}
7133
7134const ASTTemplateArgumentListInfo*
7135ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
7136 const RecordData &Record,
7137 unsigned &Index) {
7138 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
7139 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
7140 unsigned NumArgsAsWritten = Record[Index++];
7141 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
7142 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
7143 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
7144 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
7145}
7146
7147Decl *ASTReader::GetExternalDecl(uint32_t ID) {
7148 return GetDecl(ID);
7149}
7150
7151void ASTReader::CompleteRedeclChain(const Decl *D) {
7152 if (NumCurrentElementsDeserializing) {
7153 // We arrange to not care about the complete redeclaration chain while we're
7154 // deserializing. Just remember that the AST has marked this one as complete
7155 // but that it's not actually complete yet, so we know we still need to
7156 // complete it later.
7157 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
7158 return;
7159 }
7160
7161 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
7162
7163 // If this is a named declaration, complete it by looking it up
7164 // within its context.
7165 //
7166 // FIXME: Merging a function definition should merge
7167 // all mergeable entities within it.
7168 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
7169 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
7170 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
7171 if (!getContext().getLangOpts().CPlusPlus &&
7172 isa<TranslationUnitDecl>(DC)) {
7173 // Outside of C++, we don't have a lookup table for the TU, so update
7174 // the identifier instead. (For C++ modules, we don't store decls
7175 // in the serialized identifier table, so we do the lookup in the TU.)
7176 auto *II = Name.getAsIdentifierInfo();
7177 assert(II && "non-identifier name in C?")((II && "non-identifier name in C?") ? static_cast<
void> (0) : __assert_fail ("II && \"non-identifier name in C?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7177, __PRETTY_FUNCTION__))
;
7178 if (II->isOutOfDate())
7179 updateOutOfDateIdentifier(*II);
7180 } else
7181 DC->lookup(Name);
7182 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
7183 // Find all declarations of this kind from the relevant context.
7184 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
7185 auto *DC = cast<DeclContext>(DCDecl);
7186 SmallVector<Decl*, 8> Decls;
7187 FindExternalLexicalDecls(
7188 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
7189 }
7190 }
7191 }
7192
7193 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
7194 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
7195 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
7196 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
7197 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
7198 if (auto *Template = FD->getPrimaryTemplate())
7199 Template->LoadLazySpecializations();
7200 }
7201}
7202
7203CXXCtorInitializer **
7204ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
7205 RecordLocation Loc = getLocalBitOffset(Offset);
7206 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7207 SavedStreamPosition SavedPosition(Cursor);
7208 Cursor.JumpToBit(Loc.Offset);
7209 ReadingKindTracker ReadingKind(Read_Decl, *this);
7210
7211 RecordData Record;
7212 unsigned Code = Cursor.ReadCode();
7213 unsigned RecCode = Cursor.readRecord(Code, Record);
7214 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
7215 Error("malformed AST file: missing C++ ctor initializers");
7216 return nullptr;
7217 }
7218
7219 unsigned Idx = 0;
7220 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
7221}
7222
7223CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
7224 assert(ContextObj && "reading base specifiers with no AST context")((ContextObj && "reading base specifiers with no AST context"
) ? static_cast<void> (0) : __assert_fail ("ContextObj && \"reading base specifiers with no AST context\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7224, __PRETTY_FUNCTION__))
;
7225 ASTContext &Context = *ContextObj;
7226
7227 RecordLocation Loc = getLocalBitOffset(Offset);
7228 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
7229 SavedStreamPosition SavedPosition(Cursor);
7230 Cursor.JumpToBit(Loc.Offset);
7231 ReadingKindTracker ReadingKind(Read_Decl, *this);
7232 RecordData Record;
7233 unsigned Code = Cursor.ReadCode();
7234 unsigned RecCode = Cursor.readRecord(Code, Record);
7235 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
7236 Error("malformed AST file: missing C++ base specifiers");
7237 return nullptr;
7238 }
7239
7240 unsigned Idx = 0;
7241 unsigned NumBases = Record[Idx++];
7242 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
7243 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
7244 for (unsigned I = 0; I != NumBases; ++I)
7245 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
7246 return Bases;
7247}
7248
7249serialization::DeclID
7250ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
7251 if (LocalID < NUM_PREDEF_DECL_IDS)
7252 return LocalID;
7253
7254 if (!F.ModuleOffsetMap.empty())
7255 ReadModuleOffsetMap(F);
7256
7257 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7258 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
7259 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap")((I != F.DeclRemap.end() && "Invalid index into decl index remap"
) ? static_cast<void> (0) : __assert_fail ("I != F.DeclRemap.end() && \"Invalid index into decl index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7259, __PRETTY_FUNCTION__))
;
7260
7261 return LocalID + I->second;
7262}
7263
7264bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
7265 ModuleFile &M) const {
7266 // Predefined decls aren't from any module.
7267 if (ID < NUM_PREDEF_DECL_IDS)
7268 return false;
7269
7270 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
7271 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
7272}
7273
7274ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
7275 if (!D->isFromASTFile())
7276 return nullptr;
7277 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
7278 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map")((I != GlobalDeclMap.end() && "Corrupted global declaration map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalDeclMap.end() && \"Corrupted global declaration map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7278, __PRETTY_FUNCTION__))
;
7279 return I->second;
7280}
7281
7282SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
7283 if (ID < NUM_PREDEF_DECL_IDS)
7284 return SourceLocation();
7285
7286 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7287
7288 if (Index > DeclsLoaded.size()) {
7289 Error("declaration ID out-of-range for AST file");
7290 return SourceLocation();
7291 }
7292
7293 if (Decl *D = DeclsLoaded[Index])
7294 return D->getLocation();
7295
7296 SourceLocation Loc;
7297 DeclCursorForID(ID, Loc);
7298 return Loc;
7299}
7300
7301static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
7302 switch (ID) {
7303 case PREDEF_DECL_NULL_ID:
7304 return nullptr;
7305
7306 case PREDEF_DECL_TRANSLATION_UNIT_ID:
7307 return Context.getTranslationUnitDecl();
7308
7309 case PREDEF_DECL_OBJC_ID_ID:
7310 return Context.getObjCIdDecl();
7311
7312 case PREDEF_DECL_OBJC_SEL_ID:
7313 return Context.getObjCSelDecl();
7314
7315 case PREDEF_DECL_OBJC_CLASS_ID:
7316 return Context.getObjCClassDecl();
7317
7318 case PREDEF_DECL_OBJC_PROTOCOL_ID:
7319 return Context.getObjCProtocolDecl();
7320
7321 case PREDEF_DECL_INT_128_ID:
7322 return Context.getInt128Decl();
7323
7324 case PREDEF_DECL_UNSIGNED_INT_128_ID:
7325 return Context.getUInt128Decl();
7326
7327 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
7328 return Context.getObjCInstanceTypeDecl();
7329
7330 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
7331 return Context.getBuiltinVaListDecl();
7332
7333 case PREDEF_DECL_VA_LIST_TAG:
7334 return Context.getVaListTagDecl();
7335
7336 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
7337 return Context.getBuiltinMSVaListDecl();
7338
7339 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
7340 return Context.getExternCContextDecl();
7341
7342 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
7343 return Context.getMakeIntegerSeqDecl();
7344
7345 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
7346 return Context.getCFConstantStringDecl();
7347
7348 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
7349 return Context.getCFConstantStringTagDecl();
7350
7351 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
7352 return Context.getTypePackElementDecl();
7353 }
7354 llvm_unreachable("PredefinedDeclIDs unknown enum value")::llvm::llvm_unreachable_internal("PredefinedDeclIDs unknown enum value"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7354)
;
7355}
7356
7357Decl *ASTReader::GetExistingDecl(DeclID ID) {
7358 assert(ContextObj && "reading decl with no AST context")((ContextObj && "reading decl with no AST context") ?
static_cast<void> (0) : __assert_fail ("ContextObj && \"reading decl with no AST context\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7358, __PRETTY_FUNCTION__))
;
7359 if (ID < NUM_PREDEF_DECL_IDS) {
7360 Decl *D = getPredefinedDecl(*ContextObj, (PredefinedDeclIDs)ID);
7361 if (D) {
7362 // Track that we have merged the declaration with ID \p ID into the
7363 // pre-existing predefined declaration \p D.
7364 auto &Merged = KeyDecls[D->getCanonicalDecl()];
7365 if (Merged.empty())
7366 Merged.push_back(ID);
7367 }
7368 return D;
7369 }
7370
7371 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7372
7373 if (Index >= DeclsLoaded.size()) {
7374 assert(0 && "declaration ID out-of-range for AST file")((0 && "declaration ID out-of-range for AST file") ? static_cast
<void> (0) : __assert_fail ("0 && \"declaration ID out-of-range for AST file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7374, __PRETTY_FUNCTION__))
;
7375 Error("declaration ID out-of-range for AST file");
7376 return nullptr;
7377 }
7378
7379 return DeclsLoaded[Index];
7380}
7381
7382Decl *ASTReader::GetDecl(DeclID ID) {
7383 if (ID < NUM_PREDEF_DECL_IDS)
7384 return GetExistingDecl(ID);
7385
7386 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
7387
7388 if (Index >= DeclsLoaded.size()) {
7389 assert(0 && "declaration ID out-of-range for AST file")((0 && "declaration ID out-of-range for AST file") ? static_cast
<void> (0) : __assert_fail ("0 && \"declaration ID out-of-range for AST file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7389, __PRETTY_FUNCTION__))
;
7390 Error("declaration ID out-of-range for AST file");
7391 return nullptr;
7392 }
7393
7394 if (!DeclsLoaded[Index]) {
7395 ReadDeclRecord(ID);
7396 if (DeserializationListener)
7397 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
7398 }
7399
7400 return DeclsLoaded[Index];
7401}
7402
7403DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
7404 DeclID GlobalID) {
7405 if (GlobalID < NUM_PREDEF_DECL_IDS)
7406 return GlobalID;
7407
7408 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
7409 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map")((I != GlobalDeclMap.end() && "Corrupted global declaration map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalDeclMap.end() && \"Corrupted global declaration map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7409, __PRETTY_FUNCTION__))
;
7410 ModuleFile *Owner = I->second;
7411
7412 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
7413 = M.GlobalToLocalDeclIDs.find(Owner);
7414 if (Pos == M.GlobalToLocalDeclIDs.end())
7415 return 0;
7416
7417 return GlobalID - Owner->BaseDeclID + Pos->second;
7418}
7419
7420serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
7421 const RecordData &Record,
7422 unsigned &Idx) {
7423 if (Idx >= Record.size()) {
7424 Error("Corrupted AST file");
7425 return 0;
7426 }
7427
7428 return getGlobalDeclID(F, Record[Idx++]);
7429}
7430
7431/// Resolve the offset of a statement into a statement.
7432///
7433/// This operation will read a new statement from the external
7434/// source each time it is called, and is meant to be used via a
7435/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
7436Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
7437 // Switch case IDs are per Decl.
7438 ClearSwitchCaseIDs();
7439
7440 // Offset here is a global offset across the entire chain.
7441 RecordLocation Loc = getLocalBitOffset(Offset);
7442 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
7443 assert(NumCurrentElementsDeserializing == 0 &&((NumCurrentElementsDeserializing == 0 && "should not be called while already deserializing"
) ? static_cast<void> (0) : __assert_fail ("NumCurrentElementsDeserializing == 0 && \"should not be called while already deserializing\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7444, __PRETTY_FUNCTION__))
7444 "should not be called while already deserializing")((NumCurrentElementsDeserializing == 0 && "should not be called while already deserializing"
) ? static_cast<void> (0) : __assert_fail ("NumCurrentElementsDeserializing == 0 && \"should not be called while already deserializing\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7444, __PRETTY_FUNCTION__))
;
7445 Deserializing D(this);
7446 return ReadStmtFromStream(*Loc.F);
7447}
7448
7449void ASTReader::FindExternalLexicalDecls(
7450 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
7451 SmallVectorImpl<Decl *> &Decls) {
7452 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
7453
7454 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
7455 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries")((LexicalDecls.size() % 2 == 0 && "expected an even number of entries"
) ? static_cast<void> (0) : __assert_fail ("LexicalDecls.size() % 2 == 0 && \"expected an even number of entries\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7455, __PRETTY_FUNCTION__))
;
7456 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
7457 auto K = (Decl::Kind)+LexicalDecls[I];
7458 if (!IsKindWeWant(K))
7459 continue;
7460
7461 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
7462
7463 // Don't add predefined declarations to the lexical context more
7464 // than once.
7465 if (ID < NUM_PREDEF_DECL_IDS) {
7466 if (PredefsVisited[ID])
7467 continue;
7468
7469 PredefsVisited[ID] = true;
7470 }
7471
7472 if (Decl *D = GetLocalDecl(*M, ID)) {
7473 assert(D->getKind() == K && "wrong kind for lexical decl")((D->getKind() == K && "wrong kind for lexical decl"
) ? static_cast<void> (0) : __assert_fail ("D->getKind() == K && \"wrong kind for lexical decl\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7473, __PRETTY_FUNCTION__))
;
7474 if (!DC->isDeclInLexicalTraversal(D))
7475 Decls.push_back(D);
7476 }
7477 }
7478 };
7479
7480 if (isa<TranslationUnitDecl>(DC)) {
7481 for (auto Lexical : TULexicalDecls)
7482 Visit(Lexical.first, Lexical.second);
7483 } else {
7484 auto I = LexicalDecls.find(DC);
7485 if (I != LexicalDecls.end())
7486 Visit(I->second.first, I->second.second);
7487 }
7488
7489 ++NumLexicalDeclContextsRead;
7490}
7491
7492namespace {
7493
7494class DeclIDComp {
7495 ASTReader &Reader;
7496 ModuleFile &Mod;
7497
7498public:
7499 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
7500
7501 bool operator()(LocalDeclID L, LocalDeclID R) const {
7502 SourceLocation LHS = getLocation(L);
7503 SourceLocation RHS = getLocation(R);
7504 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7505 }
7506
7507 bool operator()(SourceLocation LHS, LocalDeclID R) const {
7508 SourceLocation RHS = getLocation(R);
7509 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7510 }
7511
7512 bool operator()(LocalDeclID L, SourceLocation RHS) const {
7513 SourceLocation LHS = getLocation(L);
7514 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
7515 }
7516
7517 SourceLocation getLocation(LocalDeclID ID) const {
7518 return Reader.getSourceManager().getFileLoc(
7519 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
7520 }
7521};
7522
7523} // namespace
7524
7525void ASTReader::FindFileRegionDecls(FileID File,
7526 unsigned Offset, unsigned Length,
7527 SmallVectorImpl<Decl *> &Decls) {
7528 SourceManager &SM = getSourceManager();
7529
7530 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
7531 if (I == FileDeclIDs.end())
7532 return;
7533
7534 FileDeclsInfo &DInfo = I->second;
7535 if (DInfo.Decls.empty())
7536 return;
7537
7538 SourceLocation
7539 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
7540 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
7541
7542 DeclIDComp DIDComp(*this, *DInfo.Mod);
7543 ArrayRef<serialization::LocalDeclID>::iterator
7544 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7545 BeginLoc, DIDComp);
7546 if (BeginIt != DInfo.Decls.begin())
7547 --BeginIt;
7548
7549 // If we are pointing at a top-level decl inside an objc container, we need
7550 // to backtrack until we find it otherwise we will fail to report that the
7551 // region overlaps with an objc container.
7552 while (BeginIt != DInfo.Decls.begin() &&
7553 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
7554 ->isTopLevelDeclInObjCContainer())
7555 --BeginIt;
7556
7557 ArrayRef<serialization::LocalDeclID>::iterator
7558 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
7559 EndLoc, DIDComp);
7560 if (EndIt != DInfo.Decls.end())
7561 ++EndIt;
7562
7563 for (ArrayRef<serialization::LocalDeclID>::iterator
7564 DIt = BeginIt; DIt != EndIt; ++DIt)
7565 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
7566}
7567
7568bool
7569ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
7570 DeclarationName Name) {
7571 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&((DC->hasExternalVisibleStorage() && DC == DC->
getPrimaryContext() && "DeclContext has no visible decls in storage"
) ? static_cast<void> (0) : __assert_fail ("DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() && \"DeclContext has no visible decls in storage\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7572, __PRETTY_FUNCTION__))
7572 "DeclContext has no visible decls in storage")((DC->hasExternalVisibleStorage() && DC == DC->
getPrimaryContext() && "DeclContext has no visible decls in storage"
) ? static_cast<void> (0) : __assert_fail ("DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() && \"DeclContext has no visible decls in storage\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7572, __PRETTY_FUNCTION__))
;
7573 if (!Name)
7574 return false;
7575
7576 auto It = Lookups.find(DC);
7577 if (It == Lookups.end())
7578 return false;
7579
7580 Deserializing LookupResults(this);
7581
7582 // Load the list of declarations.
7583 SmallVector<NamedDecl *, 64> Decls;
7584 for (DeclID ID : It->second.Table.find(Name)) {
7585 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7586 if (ND->getDeclName() == Name)
7587 Decls.push_back(ND);
7588 }
7589
7590 ++NumVisibleDeclContextsRead;
7591 SetExternalVisibleDeclsForName(DC, Name, Decls);
7592 return !Decls.empty();
7593}
7594
7595void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
7596 if (!DC->hasExternalVisibleStorage())
7597 return;
7598
7599 auto It = Lookups.find(DC);
7600 assert(It != Lookups.end() &&((It != Lookups.end() && "have external visible storage but no lookup tables"
) ? static_cast<void> (0) : __assert_fail ("It != Lookups.end() && \"have external visible storage but no lookup tables\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7601, __PRETTY_FUNCTION__))
7601 "have external visible storage but no lookup tables")((It != Lookups.end() && "have external visible storage but no lookup tables"
) ? static_cast<void> (0) : __assert_fail ("It != Lookups.end() && \"have external visible storage but no lookup tables\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7601, __PRETTY_FUNCTION__))
;
7602
7603 DeclsMap Decls;
7604
7605 for (DeclID ID : It->second.Table.findAll()) {
7606 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
7607 Decls[ND->getDeclName()].push_back(ND);
7608 }
7609
7610 ++NumVisibleDeclContextsRead;
7611
7612 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
7613 SetExternalVisibleDeclsForName(DC, I->first, I->second);
7614 }
7615 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
7616}
7617
7618const serialization::reader::DeclContextLookupTable *
7619ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
7620 auto I = Lookups.find(Primary);
7621 return I == Lookups.end() ? nullptr : &I->second;
7622}
7623
7624/// Under non-PCH compilation the consumer receives the objc methods
7625/// before receiving the implementation, and codegen depends on this.
7626/// We simulate this by deserializing and passing to consumer the methods of the
7627/// implementation before passing the deserialized implementation decl.
7628static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
7629 ASTConsumer *Consumer) {
7630 assert(ImplD && Consumer)((ImplD && Consumer) ? static_cast<void> (0) : __assert_fail
("ImplD && Consumer", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7630, __PRETTY_FUNCTION__))
;
7631
7632 for (auto *I : ImplD->methods())
7633 Consumer->HandleInterestingDecl(DeclGroupRef(I));
7634
7635 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
7636}
7637
7638void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
7639 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
7640 PassObjCImplDeclToConsumer(ImplD, Consumer);
7641 else
7642 Consumer->HandleInterestingDecl(DeclGroupRef(D));
7643}
7644
7645void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
7646 this->Consumer = Consumer;
7647
7648 if (Consumer)
7649 PassInterestingDeclsToConsumer();
7650
7651 if (DeserializationListener)
7652 DeserializationListener->ReaderInitialized(this);
7653}
7654
7655void ASTReader::PrintStats() {
7656 std::fprintf(stderrstderr, "*** AST File Statistics:\n");
7657
7658 unsigned NumTypesLoaded
7659 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
7660 QualType());
7661 unsigned NumDeclsLoaded
7662 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
7663 (Decl *)nullptr);
7664 unsigned NumIdentifiersLoaded
7665 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
7666 IdentifiersLoaded.end(),
7667 (IdentifierInfo *)nullptr);
7668 unsigned NumMacrosLoaded
7669 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
7670 MacrosLoaded.end(),
7671 (MacroInfo *)nullptr);
7672 unsigned NumSelectorsLoaded
7673 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
7674 SelectorsLoaded.end(),
7675 Selector());
7676
7677 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
7678 std::fprintf(stderrstderr, " %u/%u source location entries read (%f%%)\n",
7679 NumSLocEntriesRead, TotalNumSLocEntries,
7680 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
7681 if (!TypesLoaded.empty())
7682 std::fprintf(stderrstderr, " %u/%u types read (%f%%)\n",
7683 NumTypesLoaded, (unsigned)TypesLoaded.size(),
7684 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
7685 if (!DeclsLoaded.empty())
7686 std::fprintf(stderrstderr, " %u/%u declarations read (%f%%)\n",
7687 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
7688 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
7689 if (!IdentifiersLoaded.empty())
7690 std::fprintf(stderrstderr, " %u/%u identifiers read (%f%%)\n",
7691 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
7692 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
7693 if (!MacrosLoaded.empty())
7694 std::fprintf(stderrstderr, " %u/%u macros read (%f%%)\n",
7695 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
7696 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
7697 if (!SelectorsLoaded.empty())
7698 std::fprintf(stderrstderr, " %u/%u selectors read (%f%%)\n",
7699 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
7700 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
7701 if (TotalNumStatements)
7702 std::fprintf(stderrstderr, " %u/%u statements read (%f%%)\n",
7703 NumStatementsRead, TotalNumStatements,
7704 ((float)NumStatementsRead/TotalNumStatements * 100));
7705 if (TotalNumMacros)
7706 std::fprintf(stderrstderr, " %u/%u macros read (%f%%)\n",
7707 NumMacrosRead, TotalNumMacros,
7708 ((float)NumMacrosRead/TotalNumMacros * 100));
7709 if (TotalLexicalDeclContexts)
7710 std::fprintf(stderrstderr, " %u/%u lexical declcontexts read (%f%%)\n",
7711 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
7712 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
7713 * 100));
7714 if (TotalVisibleDeclContexts)
7715 std::fprintf(stderrstderr, " %u/%u visible declcontexts read (%f%%)\n",
7716 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
7717 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
7718 * 100));
7719 if (TotalNumMethodPoolEntries)
7720 std::fprintf(stderrstderr, " %u/%u method pool entries read (%f%%)\n",
7721 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
7722 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
7723 * 100));
7724 if (NumMethodPoolLookups)
7725 std::fprintf(stderrstderr, " %u/%u method pool lookups succeeded (%f%%)\n",
7726 NumMethodPoolHits, NumMethodPoolLookups,
7727 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
7728 if (NumMethodPoolTableLookups)
7729 std::fprintf(stderrstderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
7730 NumMethodPoolTableHits, NumMethodPoolTableLookups,
7731 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
7732 * 100.0));
7733 if (NumIdentifierLookupHits)
7734 std::fprintf(stderrstderr,
7735 " %u / %u identifier table lookups succeeded (%f%%)\n",
7736 NumIdentifierLookupHits, NumIdentifierLookups,
7737 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
7738
7739 if (GlobalIndex) {
7740 std::fprintf(stderrstderr, "\n");
7741 GlobalIndex->printStats();
7742 }
7743
7744 std::fprintf(stderrstderr, "\n");
7745 dump();
7746 std::fprintf(stderrstderr, "\n");
7747}
7748
7749template<typename Key, typename ModuleFile, unsigned InitialCapacity>
7750LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) static void
7751dumpModuleIDMap(StringRef Name,
7752 const ContinuousRangeMap<Key, ModuleFile *,
7753 InitialCapacity> &Map) {
7754 if (Map.begin() == Map.end())
7755 return;
7756
7757 using MapType = ContinuousRangeMap<Key, ModuleFile *, InitialCapacity>;
7758
7759 llvm::errs() << Name << ":\n";
7760 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
7761 I != IEnd; ++I) {
7762 llvm::errs() << " " << I->first << " -> " << I->second->FileName
7763 << "\n";
7764 }
7765}
7766
7767LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void ASTReader::dump() {
7768 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
7769 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
7770 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
7771 dumpModuleIDMap("Global type map", GlobalTypeMap);
7772 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
7773 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
7774 dumpModuleIDMap("Global macro map", GlobalMacroMap);
7775 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
7776 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
7777 dumpModuleIDMap("Global preprocessed entity map",
7778 GlobalPreprocessedEntityMap);
7779
7780 llvm::errs() << "\n*** PCH/Modules Loaded:";
7781 for (ModuleFile &M : ModuleMgr)
7782 M.dump();
7783}
7784
7785/// Return the amount of memory used by memory buffers, breaking down
7786/// by heap-backed versus mmap'ed memory.
7787void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
7788 for (ModuleFile &I : ModuleMgr) {
7789 if (llvm::MemoryBuffer *buf = I.Buffer) {
7790 size_t bytes = buf->getBufferSize();
7791 switch (buf->getBufferKind()) {
7792 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
7793 sizes.malloc_bytes += bytes;
7794 break;
7795 case llvm::MemoryBuffer::MemoryBuffer_MMap:
7796 sizes.mmap_bytes += bytes;
7797 break;
7798 }
7799 }
7800 }
7801}
7802
7803void ASTReader::InitializeSema(Sema &S) {
7804 SemaObj = &S;
7805 S.addExternalSource(this);
7806
7807 // Makes sure any declarations that were deserialized "too early"
7808 // still get added to the identifier's declaration chains.
7809 for (uint64_t ID : PreloadedDeclIDs) {
7810 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
7811 pushExternalDeclIntoScope(D, D->getDeclName());
7812 }
7813 PreloadedDeclIDs.clear();
7814
7815 // FIXME: What happens if these are changed by a module import?
7816 if (!FPPragmaOptions.empty()) {
7817 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS")((FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"
) ? static_cast<void> (0) : __assert_fail ("FPPragmaOptions.size() == 1 && \"Wrong number of FP_PRAGMA_OPTIONS\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7817, __PRETTY_FUNCTION__))
;
7818 SemaObj->FPFeatures = FPOptions(FPPragmaOptions[0]);
7819 }
7820
7821 SemaObj->OpenCLFeatures.copy(OpenCLExtensions);
7822 SemaObj->OpenCLTypeExtMap = OpenCLTypeExtMap;
7823 SemaObj->OpenCLDeclExtMap = OpenCLDeclExtMap;
7824
7825 UpdateSema();
7826}
7827
7828void ASTReader::UpdateSema() {
7829 assert(SemaObj && "no Sema to update")((SemaObj && "no Sema to update") ? static_cast<void
> (0) : __assert_fail ("SemaObj && \"no Sema to update\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7829, __PRETTY_FUNCTION__))
;
7830
7831 // Load the offsets of the declarations that Sema references.
7832 // They will be lazily deserialized when needed.
7833 if (!SemaDeclRefs.empty()) {
7834 assert(SemaDeclRefs.size() % 3 == 0)((SemaDeclRefs.size() % 3 == 0) ? static_cast<void> (0)
: __assert_fail ("SemaDeclRefs.size() % 3 == 0", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7834, __PRETTY_FUNCTION__))
;
7835 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 3) {
7836 if (!SemaObj->StdNamespace)
7837 SemaObj->StdNamespace = SemaDeclRefs[I];
7838 if (!SemaObj->StdBadAlloc)
7839 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7840 if (!SemaObj->StdAlignValT)
7841 SemaObj->StdAlignValT = SemaDeclRefs[I+2];
7842 }
7843 SemaDeclRefs.clear();
7844 }
7845
7846 // Update the state of pragmas. Use the same API as if we had encountered the
7847 // pragma in the source.
7848 if(OptimizeOffPragmaLocation.isValid())
7849 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
7850 if (PragmaMSStructState != -1)
7851 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
7852 if (PointersToMembersPragmaLocation.isValid()) {
7853 SemaObj->ActOnPragmaMSPointersToMembers(
7854 (LangOptions::PragmaMSPointersToMembersKind)
7855 PragmaMSPointersToMembersState,
7856 PointersToMembersPragmaLocation);
7857 }
7858 SemaObj->ForceCUDAHostDeviceDepth = ForceCUDAHostDeviceDepth;
7859
7860 if (PragmaPackCurrentValue) {
7861 // The bottom of the stack might have a default value. It must be adjusted
7862 // to the current value to ensure that the packing state is preserved after
7863 // popping entries that were included/imported from a PCH/module.
7864 bool DropFirst = false;
7865 if (!PragmaPackStack.empty() &&
7866 PragmaPackStack.front().Location.isInvalid()) {
7867 assert(PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue &&((PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue
&& "Expected a default alignment value") ? static_cast
<void> (0) : __assert_fail ("PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue && \"Expected a default alignment value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7868, __PRETTY_FUNCTION__))
7868 "Expected a default alignment value")((PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue
&& "Expected a default alignment value") ? static_cast
<void> (0) : __assert_fail ("PragmaPackStack.front().Value == SemaObj->PackStack.DefaultValue && \"Expected a default alignment value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7868, __PRETTY_FUNCTION__))
;
7869 SemaObj->PackStack.Stack.emplace_back(
7870 PragmaPackStack.front().SlotLabel, SemaObj->PackStack.CurrentValue,
7871 SemaObj->PackStack.CurrentPragmaLocation,
7872 PragmaPackStack.front().PushLocation);
7873 DropFirst = true;
7874 }
7875 for (const auto &Entry :
7876 llvm::makeArrayRef(PragmaPackStack).drop_front(DropFirst ? 1 : 0))
7877 SemaObj->PackStack.Stack.emplace_back(Entry.SlotLabel, Entry.Value,
7878 Entry.Location, Entry.PushLocation);
7879 if (PragmaPackCurrentLocation.isInvalid()) {
7880 assert(*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue &&((*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue
&& "Expected a default alignment value") ? static_cast
<void> (0) : __assert_fail ("*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue && \"Expected a default alignment value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7881, __PRETTY_FUNCTION__))
7881 "Expected a default alignment value")((*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue
&& "Expected a default alignment value") ? static_cast
<void> (0) : __assert_fail ("*PragmaPackCurrentValue == SemaObj->PackStack.DefaultValue && \"Expected a default alignment value\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 7881, __PRETTY_FUNCTION__))
;
7882 // Keep the current values.
7883 } else {
7884 SemaObj->PackStack.CurrentValue = *PragmaPackCurrentValue;
7885 SemaObj->PackStack.CurrentPragmaLocation = PragmaPackCurrentLocation;
7886 }
7887 }
7888}
7889
7890IdentifierInfo *ASTReader::get(StringRef Name) {
7891 // Note that we are loading an identifier.
7892 Deserializing AnIdentifier(this);
7893
7894 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
7895 NumIdentifierLookups,
7896 NumIdentifierLookupHits);
7897
7898 // We don't need to do identifier table lookups in C++ modules (we preload
7899 // all interesting declarations, and don't need to use the scope for name
7900 // lookups). Perform the lookup in PCH files, though, since we don't build
7901 // a complete initial identifier table if we're carrying on from a PCH.
7902 if (PP.getLangOpts().CPlusPlus) {
7903 for (auto F : ModuleMgr.pch_modules())
7904 if (Visitor(*F))
7905 break;
7906 } else {
7907 // If there is a global index, look there first to determine which modules
7908 // provably do not have any results for this identifier.
7909 GlobalModuleIndex::HitSet Hits;
7910 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7911 if (!loadGlobalIndex()) {
7912 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7913 HitsPtr = &Hits;
7914 }
7915 }
7916
7917 ModuleMgr.visit(Visitor, HitsPtr);
7918 }
7919
7920 IdentifierInfo *II = Visitor.getIdentifierInfo();
7921 markIdentifierUpToDate(II);
7922 return II;
7923}
7924
7925namespace clang {
7926
7927 /// An identifier-lookup iterator that enumerates all of the
7928 /// identifiers stored within a set of AST files.
7929 class ASTIdentifierIterator : public IdentifierIterator {
7930 /// The AST reader whose identifiers are being enumerated.
7931 const ASTReader &Reader;
7932
7933 /// The current index into the chain of AST files stored in
7934 /// the AST reader.
7935 unsigned Index;
7936
7937 /// The current position within the identifier lookup table
7938 /// of the current AST file.
7939 ASTIdentifierLookupTable::key_iterator Current;
7940
7941 /// The end position within the identifier lookup table of
7942 /// the current AST file.
7943 ASTIdentifierLookupTable::key_iterator End;
7944
7945 /// Whether to skip any modules in the ASTReader.
7946 bool SkipModules;
7947
7948 public:
7949 explicit ASTIdentifierIterator(const ASTReader &Reader,
7950 bool SkipModules = false);
7951
7952 StringRef Next() override;
7953 };
7954
7955} // namespace clang
7956
7957ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
7958 bool SkipModules)
7959 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7960}
7961
7962StringRef ASTIdentifierIterator::Next() {
7963 while (Current == End) {
7964 // If we have exhausted all of our AST files, we're done.
7965 if (Index == 0)
7966 return StringRef();
7967
7968 --Index;
7969 ModuleFile &F = Reader.ModuleMgr[Index];
7970 if (SkipModules && F.isModule())
7971 continue;
7972
7973 ASTIdentifierLookupTable *IdTable =
7974 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
7975 Current = IdTable->key_begin();
7976 End = IdTable->key_end();
7977 }
7978
7979 // We have any identifiers remaining in the current AST file; return
7980 // the next one.
7981 StringRef Result = *Current;
7982 ++Current;
7983 return Result;
7984}
7985
7986namespace {
7987
7988/// A utility for appending two IdentifierIterators.
7989class ChainedIdentifierIterator : public IdentifierIterator {
7990 std::unique_ptr<IdentifierIterator> Current;
7991 std::unique_ptr<IdentifierIterator> Queued;
7992
7993public:
7994 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7995 std::unique_ptr<IdentifierIterator> Second)
7996 : Current(std::move(First)), Queued(std::move(Second)) {}
7997
7998 StringRef Next() override {
7999 if (!Current)
8000 return StringRef();
8001
8002 StringRef result = Current->Next();
8003 if (!result.empty())
8004 return result;
8005
8006 // Try the queued iterator, which may itself be empty.
8007 Current.reset();
8008 std::swap(Current, Queued);
8009 return Next();
8010 }
8011};
8012
8013} // namespace
8014
8015IdentifierIterator *ASTReader::getIdentifiers() {
8016 if (!loadGlobalIndex()) {
8017 std::unique_ptr<IdentifierIterator> ReaderIter(
8018 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
8019 std::unique_ptr<IdentifierIterator> ModulesIter(
8020 GlobalIndex->createIdentifierIterator());
8021 return new ChainedIdentifierIterator(std::move(ReaderIter),
8022 std::move(ModulesIter));
8023 }
8024
8025 return new ASTIdentifierIterator(*this);
8026}
8027
8028namespace clang {
8029namespace serialization {
8030
8031 class ReadMethodPoolVisitor {
8032 ASTReader &Reader;
8033 Selector Sel;
8034 unsigned PriorGeneration;
8035 unsigned InstanceBits = 0;
8036 unsigned FactoryBits = 0;
8037 bool InstanceHasMoreThanOneDecl = false;
8038 bool FactoryHasMoreThanOneDecl = false;
8039 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
8040 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
8041
8042 public:
8043 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
8044 unsigned PriorGeneration)
8045 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration) {}
8046
8047 bool operator()(ModuleFile &M) {
8048 if (!M.SelectorLookupTable)
8049 return false;
8050
8051 // If we've already searched this module file, skip it now.
8052 if (M.Generation <= PriorGeneration)
8053 return true;
8054
8055 ++Reader.NumMethodPoolTableLookups;
8056 ASTSelectorLookupTable *PoolTable
8057 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
8058 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
8059 if (Pos == PoolTable->end())
8060 return false;
8061
8062 ++Reader.NumMethodPoolTableHits;
8063 ++Reader.NumSelectorsRead;
8064 // FIXME: Not quite happy with the statistics here. We probably should
8065 // disable this tracking when called via LoadSelector.
8066 // Also, should entries without methods count as misses?
8067 ++Reader.NumMethodPoolEntriesRead;
8068 ASTSelectorLookupTrait::data_type Data = *Pos;
8069 if (Reader.DeserializationListener)
8070 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
8071
8072 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
8073 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
8074 InstanceBits = Data.InstanceBits;
8075 FactoryBits = Data.FactoryBits;
8076 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
8077 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
8078 return true;
8079 }
8080
8081 /// Retrieve the instance methods found by this visitor.
8082 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
8083 return InstanceMethods;
8084 }
8085
8086 /// Retrieve the instance methods found by this visitor.
8087 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
8088 return FactoryMethods;
8089 }
8090
8091 unsigned getInstanceBits() const { return InstanceBits; }
8092 unsigned getFactoryBits() const { return FactoryBits; }
8093
8094 bool instanceHasMoreThanOneDecl() const {
8095 return InstanceHasMoreThanOneDecl;
8096 }
8097
8098 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
8099 };
8100
8101} // namespace serialization
8102} // namespace clang
8103
8104/// Add the given set of methods to the method list.
8105static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
8106 ObjCMethodList &List) {
8107 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
8108 S.addMethodToGlobalList(&List, Methods[I]);
8109 }
8110}
8111
8112void ASTReader::ReadMethodPool(Selector Sel) {
8113 // Get the selector generation and update it to the current generation.
8114 unsigned &Generation = SelectorGeneration[Sel];
8115 unsigned PriorGeneration = Generation;
8116 Generation = getGeneration();
8117 SelectorOutOfDate[Sel] = false;
8118
8119 // Search for methods defined with this selector.
8120 ++NumMethodPoolLookups;
8121 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
8122 ModuleMgr.visit(Visitor);
8123
8124 if (Visitor.getInstanceMethods().empty() &&
8125 Visitor.getFactoryMethods().empty())
8126 return;
8127
8128 ++NumMethodPoolHits;
8129
8130 if (!getSema())
8131 return;
8132
8133 Sema &S = *getSema();
8134 Sema::GlobalMethodPool::iterator Pos
8135 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
8136
8137 Pos->second.first.setBits(Visitor.getInstanceBits());
8138 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
8139 Pos->second.second.setBits(Visitor.getFactoryBits());
8140 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
8141
8142 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
8143 // when building a module we keep every method individually and may need to
8144 // update hasMoreThanOneDecl as we add the methods.
8145 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
8146 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
8147}
8148
8149void ASTReader::updateOutOfDateSelector(Selector Sel) {
8150 if (SelectorOutOfDate[Sel])
8151 ReadMethodPool(Sel);
8152}
8153
8154void ASTReader::ReadKnownNamespaces(
8155 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
8156 Namespaces.clear();
8157
8158 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
8159 if (NamespaceDecl *Namespace
8160 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
8161 Namespaces.push_back(Namespace);
8162 }
8163}
8164
8165void ASTReader::ReadUndefinedButUsed(
8166 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
8167 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
8168 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
8169 SourceLocation Loc =
8170 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
8171 Undefined.insert(std::make_pair(D, Loc));
8172 }
8173}
8174
8175void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
8176 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
8177 Exprs) {
8178 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
8179 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
8180 uint64_t Count = DelayedDeleteExprs[Idx++];
8181 for (uint64_t C = 0; C < Count; ++C) {
8182 SourceLocation DeleteLoc =
8183 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
8184 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
8185 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
8186 }
8187 }
8188}
8189
8190void ASTReader::ReadTentativeDefinitions(
8191 SmallVectorImpl<VarDecl *> &TentativeDefs) {
8192 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
8193 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
8194 if (Var)
8195 TentativeDefs.push_back(Var);
8196 }
8197 TentativeDefinitions.clear();
8198}
8199
8200void ASTReader::ReadUnusedFileScopedDecls(
8201 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
8202 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
8203 DeclaratorDecl *D
8204 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
8205 if (D)
8206 Decls.push_back(D);
8207 }
8208 UnusedFileScopedDecls.clear();
8209}
8210
8211void ASTReader::ReadDelegatingConstructors(
8212 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
8213 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
8214 CXXConstructorDecl *D
8215 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
8216 if (D)
8217 Decls.push_back(D);
8218 }
8219 DelegatingCtorDecls.clear();
8220}
8221
8222void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
8223 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
8224 TypedefNameDecl *D
8225 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
8226 if (D)
8227 Decls.push_back(D);
8228 }
8229 ExtVectorDecls.clear();
8230}
8231
8232void ASTReader::ReadUnusedLocalTypedefNameCandidates(
8233 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
8234 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
8235 ++I) {
8236 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
8237 GetDecl(UnusedLocalTypedefNameCandidates[I]));
8238 if (D)
8239 Decls.insert(D);
8240 }
8241 UnusedLocalTypedefNameCandidates.clear();
8242}
8243
8244void ASTReader::ReadReferencedSelectors(
8245 SmallVectorImpl<std::pair<Selector, SourceLocation>> &Sels) {
8246 if (ReferencedSelectorsData.empty())
8247 return;
8248
8249 // If there are @selector references added them to its pool. This is for
8250 // implementation of -Wselector.
8251 unsigned int DataSize = ReferencedSelectorsData.size()-1;
8252 unsigned I = 0;
8253 while (I < DataSize) {
8254 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
8255 SourceLocation SelLoc
8256 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
8257 Sels.push_back(std::make_pair(Sel, SelLoc));
8258 }
8259 ReferencedSelectorsData.clear();
8260}
8261
8262void ASTReader::ReadWeakUndeclaredIdentifiers(
8263 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo>> &WeakIDs) {
8264 if (WeakUndeclaredIdentifiers.empty())
8265 return;
8266
8267 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
8268 IdentifierInfo *WeakId
8269 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8270 IdentifierInfo *AliasId
8271 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
8272 SourceLocation Loc
8273 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
8274 bool Used = WeakUndeclaredIdentifiers[I++];
8275 WeakInfo WI(AliasId, Loc);
8276 WI.setUsed(Used);
8277 WeakIDs.push_back(std::make_pair(WeakId, WI));
8278 }
8279 WeakUndeclaredIdentifiers.clear();
8280}
8281
8282void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
8283 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
8284 ExternalVTableUse VT;
8285 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
8286 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
8287 VT.DefinitionRequired = VTableUses[Idx++];
8288 VTables.push_back(VT);
8289 }
8290
8291 VTableUses.clear();
8292}
8293
8294void ASTReader::ReadPendingInstantiations(
8295 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation>> &Pending) {
8296 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
8297 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
8298 SourceLocation Loc
8299 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
8300
8301 Pending.push_back(std::make_pair(D, Loc));
8302 }
8303 PendingInstantiations.clear();
8304}
8305
8306void ASTReader::ReadLateParsedTemplates(
8307 llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
8308 &LPTMap) {
8309 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
8310 /* In loop */) {
8311 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
8312
8313 auto LT = llvm::make_unique<LateParsedTemplate>();
8314 LT->D = GetDecl(LateParsedTemplates[Idx++]);
8315
8316 ModuleFile *F = getOwningModuleFile(LT->D);
8317 assert(F && "No module")((F && "No module") ? static_cast<void> (0) : __assert_fail
("F && \"No module\"", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8317, __PRETTY_FUNCTION__))
;
8318
8319 unsigned TokN = LateParsedTemplates[Idx++];
8320 LT->Toks.reserve(TokN);
8321 for (unsigned T = 0; T < TokN; ++T)
8322 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
8323
8324 LPTMap.insert(std::make_pair(FD, std::move(LT)));
8325 }
8326
8327 LateParsedTemplates.clear();
8328}
8329
8330void ASTReader::LoadSelector(Selector Sel) {
8331 // It would be complicated to avoid reading the methods anyway. So don't.
8332 ReadMethodPool(Sel);
8333}
8334
8335void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
8336 assert(ID && "Non-zero identifier ID required")((ID && "Non-zero identifier ID required") ? static_cast
<void> (0) : __assert_fail ("ID && \"Non-zero identifier ID required\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8336, __PRETTY_FUNCTION__))
;
8337 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range")((ID <= IdentifiersLoaded.size() && "identifier ID out of range"
) ? static_cast<void> (0) : __assert_fail ("ID <= IdentifiersLoaded.size() && \"identifier ID out of range\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8337, __PRETTY_FUNCTION__))
;
8338 IdentifiersLoaded[ID - 1] = II;
8339 if (DeserializationListener)
8340 DeserializationListener->IdentifierRead(ID, II);
8341}
8342
8343/// Set the globally-visible declarations associated with the given
8344/// identifier.
8345///
8346/// If the AST reader is currently in a state where the given declaration IDs
8347/// cannot safely be resolved, they are queued until it is safe to resolve
8348/// them.
8349///
8350/// \param II an IdentifierInfo that refers to one or more globally-visible
8351/// declarations.
8352///
8353/// \param DeclIDs the set of declaration IDs with the name @p II that are
8354/// visible at global scope.
8355///
8356/// \param Decls if non-null, this vector will be populated with the set of
8357/// deserialized declarations. These declarations will not be pushed into
8358/// scope.
8359void
8360ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
8361 const SmallVectorImpl<uint32_t> &DeclIDs,
8362 SmallVectorImpl<Decl *> *Decls) {
8363 if (NumCurrentElementsDeserializing && !Decls) {
8364 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
8365 return;
8366 }
8367
8368 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
8369 if (!SemaObj) {
8370 // Queue this declaration so that it will be added to the
8371 // translation unit scope and identifier's declaration chain
8372 // once a Sema object is known.
8373 PreloadedDeclIDs.push_back(DeclIDs[I]);
8374 continue;
8375 }
8376
8377 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
8378
8379 // If we're simply supposed to record the declarations, do so now.
8380 if (Decls) {
8381 Decls->push_back(D);
8382 continue;
8383 }
8384
8385 // Introduce this declaration into the translation-unit scope
8386 // and add it to the declaration chain for this identifier, so
8387 // that (unqualified) name lookup will find it.
8388 pushExternalDeclIntoScope(D, II);
8389 }
8390}
8391
8392IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
8393 if (ID == 0)
8394 return nullptr;
8395
8396 if (IdentifiersLoaded.empty()) {
8397 Error("no identifier table in AST file");
8398 return nullptr;
8399 }
8400
8401 ID -= 1;
8402 if (!IdentifiersLoaded[ID]) {
8403 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
8404 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map")((I != GlobalIdentifierMap.end() && "Corrupted global identifier map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalIdentifierMap.end() && \"Corrupted global identifier map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8404, __PRETTY_FUNCTION__))
;
8405 ModuleFile *M = I->second;
8406 unsigned Index = ID - M->BaseIdentifierID;
8407 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
8408
8409 // All of the strings in the AST file are preceded by a 16-bit length.
8410 // Extract that 16-bit length to avoid having to execute strlen().
8411 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
8412 // unsigned integers. This is important to avoid integer overflow when
8413 // we cast them to 'unsigned'.
8414 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
8415 unsigned StrLen = (((unsigned) StrLenPtr[0])
8416 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
8417 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
8418 IdentifiersLoaded[ID] = &II;
8419 markIdentifierFromAST(*this, II);
8420 if (DeserializationListener)
8421 DeserializationListener->IdentifierRead(ID + 1, &II);
8422 }
8423
8424 return IdentifiersLoaded[ID];
8425}
8426
8427IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
8428 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
8429}
8430
8431IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
8432 if (LocalID < NUM_PREDEF_IDENT_IDS)
8433 return LocalID;
8434
8435 if (!M.ModuleOffsetMap.empty())
8436 ReadModuleOffsetMap(M);
8437
8438 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8439 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
8440 assert(I != M.IdentifierRemap.end()((I != M.IdentifierRemap.end() && "Invalid index into identifier index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.IdentifierRemap.end() && \"Invalid index into identifier index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8441, __PRETTY_FUNCTION__))
8441 && "Invalid index into identifier index remap")((I != M.IdentifierRemap.end() && "Invalid index into identifier index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.IdentifierRemap.end() && \"Invalid index into identifier index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8441, __PRETTY_FUNCTION__))
;
8442
8443 return LocalID + I->second;
8444}
8445
8446MacroInfo *ASTReader::getMacro(MacroID ID) {
8447 if (ID == 0)
8448 return nullptr;
8449
8450 if (MacrosLoaded.empty()) {
8451 Error("no macro table in AST file");
8452 return nullptr;
8453 }
8454
8455 ID -= NUM_PREDEF_MACRO_IDS;
8456 if (!MacrosLoaded[ID]) {
8457 GlobalMacroMapType::iterator I
8458 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
8459 assert(I != GlobalMacroMap.end() && "Corrupted global macro map")((I != GlobalMacroMap.end() && "Corrupted global macro map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalMacroMap.end() && \"Corrupted global macro map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8459, __PRETTY_FUNCTION__))
;
8460 ModuleFile *M = I->second;
8461 unsigned Index = ID - M->BaseMacroID;
8462 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
8463
8464 if (DeserializationListener)
8465 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
8466 MacrosLoaded[ID]);
8467 }
8468
8469 return MacrosLoaded[ID];
8470}
8471
8472MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
8473 if (LocalID < NUM_PREDEF_MACRO_IDS)
8474 return LocalID;
8475
8476 if (!M.ModuleOffsetMap.empty())
8477 ReadModuleOffsetMap(M);
8478
8479 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8480 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
8481 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap")((I != M.MacroRemap.end() && "Invalid index into macro index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.MacroRemap.end() && \"Invalid index into macro index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8481, __PRETTY_FUNCTION__))
;
8482
8483 return LocalID + I->second;
8484}
8485
8486serialization::SubmoduleID
8487ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
8488 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
8489 return LocalID;
8490
8491 if (!M.ModuleOffsetMap.empty())
8492 ReadModuleOffsetMap(M);
8493
8494 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8495 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
8496 assert(I != M.SubmoduleRemap.end()((I != M.SubmoduleRemap.end() && "Invalid index into submodule index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.SubmoduleRemap.end() && \"Invalid index into submodule index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8497, __PRETTY_FUNCTION__))
8497 && "Invalid index into submodule index remap")((I != M.SubmoduleRemap.end() && "Invalid index into submodule index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.SubmoduleRemap.end() && \"Invalid index into submodule index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8497, __PRETTY_FUNCTION__))
;
8498
8499 return LocalID + I->second;
8500}
8501
8502Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
8503 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
8504 assert(GlobalID == 0 && "Unhandled global submodule ID")((GlobalID == 0 && "Unhandled global submodule ID") ?
static_cast<void> (0) : __assert_fail ("GlobalID == 0 && \"Unhandled global submodule ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8504, __PRETTY_FUNCTION__))
;
8505 return nullptr;
8506 }
8507
8508 if (GlobalID > SubmodulesLoaded.size()) {
8509 Error("submodule ID out of range in AST file");
8510 return nullptr;
8511 }
8512
8513 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
8514}
8515
8516Module *ASTReader::getModule(unsigned ID) {
8517 return getSubmodule(ID);
8518}
8519
8520bool ASTReader::DeclIsFromPCHWithObjectFile(const Decl *D) {
8521 ModuleFile *MF = getOwningModuleFile(D);
8522 return MF && MF->PCHHasObjectFile;
8523}
8524
8525ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
8526 if (ID & 1) {
8527 // It's a module, look it up by submodule ID.
8528 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
8529 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
8530 } else {
8531 // It's a prefix (preamble, PCH, ...). Look it up by index.
8532 unsigned IndexFromEnd = ID >> 1;
8533 assert(IndexFromEnd && "got reference to unknown module file")((IndexFromEnd && "got reference to unknown module file"
) ? static_cast<void> (0) : __assert_fail ("IndexFromEnd && \"got reference to unknown module file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8533, __PRETTY_FUNCTION__))
;
8534 return getModuleManager().pch_modules().end()[-IndexFromEnd];
8535 }
8536}
8537
8538unsigned ASTReader::getModuleFileID(ModuleFile *F) {
8539 if (!F)
8540 return 1;
8541
8542 // For a file representing a module, use the submodule ID of the top-level
8543 // module as the file ID. For any other kind of file, the number of such
8544 // files loaded beforehand will be the same on reload.
8545 // FIXME: Is this true even if we have an explicit module file and a PCH?
8546 if (F->isModule())
8547 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
8548
8549 auto PCHModules = getModuleManager().pch_modules();
8550 auto I = llvm::find(PCHModules, F);
8551 assert(I != PCHModules.end() && "emitting reference to unknown file")((I != PCHModules.end() && "emitting reference to unknown file"
) ? static_cast<void> (0) : __assert_fail ("I != PCHModules.end() && \"emitting reference to unknown file\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8551, __PRETTY_FUNCTION__))
;
8552 return (I - PCHModules.end()) << 1;
8553}
8554
8555llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
8556ASTReader::getSourceDescriptor(unsigned ID) {
8557 if (const Module *M = getSubmodule(ID))
8558 return ExternalASTSource::ASTSourceDescriptor(*M);
8559
8560 // If there is only a single PCH, return it instead.
8561 // Chained PCH are not supported.
8562 const auto &PCHChain = ModuleMgr.pch_modules();
8563 if (std::distance(std::begin(PCHChain), std::end(PCHChain))) {
8564 ModuleFile &MF = ModuleMgr.getPrimaryModule();
8565 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
8566 StringRef FileName = llvm::sys::path::filename(MF.FileName);
8567 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
8568 MF.Signature);
8569 }
8570 return None;
8571}
8572
8573ExternalASTSource::ExtKind ASTReader::hasExternalDefinitions(const Decl *FD) {
8574 auto I = DefinitionSource.find(FD);
8575 if (I == DefinitionSource.end())
8576 return EK_ReplyHazy;
8577 return I->second ? EK_Never : EK_Always;
8578}
8579
8580Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
8581 return DecodeSelector(getGlobalSelectorID(M, LocalID));
8582}
8583
8584Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
8585 if (ID == 0)
8586 return Selector();
8587
8588 if (ID > SelectorsLoaded.size()) {
8589 Error("selector ID out of range in AST file");
8590 return Selector();
8591 }
8592
8593 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
8594 // Load this selector from the selector table.
8595 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
8596 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map")((I != GlobalSelectorMap.end() && "Corrupted global selector map"
) ? static_cast<void> (0) : __assert_fail ("I != GlobalSelectorMap.end() && \"Corrupted global selector map\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8596, __PRETTY_FUNCTION__))
;
8597 ModuleFile &M = *I->second;
8598 ASTSelectorLookupTrait Trait(*this, M);
8599 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
8600 SelectorsLoaded[ID - 1] =
8601 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
8602 if (DeserializationListener)
8603 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
8604 }
8605
8606 return SelectorsLoaded[ID - 1];
8607}
8608
8609Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
8610 return DecodeSelector(ID);
8611}
8612
8613uint32_t ASTReader::GetNumExternalSelectors() {
8614 // ID 0 (the null selector) is considered an external selector.
8615 return getTotalNumSelectors() + 1;
8616}
8617
8618serialization::SelectorID
8619ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
8620 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
8621 return LocalID;
8622
8623 if (!M.ModuleOffsetMap.empty())
8624 ReadModuleOffsetMap(M);
8625
8626 ContinuousRangeMap<uint32_t, int, 2>::iterator I
8627 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
8628 assert(I != M.SelectorRemap.end()((I != M.SelectorRemap.end() && "Invalid index into selector index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.SelectorRemap.end() && \"Invalid index into selector index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8629, __PRETTY_FUNCTION__))
8629 && "Invalid index into selector index remap")((I != M.SelectorRemap.end() && "Invalid index into selector index remap"
) ? static_cast<void> (0) : __assert_fail ("I != M.SelectorRemap.end() && \"Invalid index into selector index remap\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8629, __PRETTY_FUNCTION__))
;
8630
8631 return LocalID + I->second;
8632}
8633
8634DeclarationName
8635ASTReader::ReadDeclarationName(ModuleFile &F,
8636 const RecordData &Record, unsigned &Idx) {
8637 ASTContext &Context = getContext();
8638 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
8639 switch (Kind) {
8640 case DeclarationName::Identifier:
8641 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
8642
8643 case DeclarationName::ObjCZeroArgSelector:
8644 case DeclarationName::ObjCOneArgSelector:
8645 case DeclarationName::ObjCMultiArgSelector:
8646 return DeclarationName(ReadSelector(F, Record, Idx));
8647
8648 case DeclarationName::CXXConstructorName:
8649 return Context.DeclarationNames.getCXXConstructorName(
8650 Context.getCanonicalType(readType(F, Record, Idx)));
8651
8652 case DeclarationName::CXXDestructorName:
8653 return Context.DeclarationNames.getCXXDestructorName(
8654 Context.getCanonicalType(readType(F, Record, Idx)));
8655
8656 case DeclarationName::CXXDeductionGuideName:
8657 return Context.DeclarationNames.getCXXDeductionGuideName(
8658 ReadDeclAs<TemplateDecl>(F, Record, Idx));
8659
8660 case DeclarationName::CXXConversionFunctionName:
8661 return Context.DeclarationNames.getCXXConversionFunctionName(
8662 Context.getCanonicalType(readType(F, Record, Idx)));
8663
8664 case DeclarationName::CXXOperatorName:
8665 return Context.DeclarationNames.getCXXOperatorName(
8666 (OverloadedOperatorKind)Record[Idx++]);
8667
8668 case DeclarationName::CXXLiteralOperatorName:
8669 return Context.DeclarationNames.getCXXLiteralOperatorName(
8670 GetIdentifierInfo(F, Record, Idx));
8671
8672 case DeclarationName::CXXUsingDirective:
8673 return DeclarationName::getUsingDirectiveName();
8674 }
8675
8676 llvm_unreachable("Invalid NameKind!")::llvm::llvm_unreachable_internal("Invalid NameKind!", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8676)
;
8677}
8678
8679void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
8680 DeclarationNameLoc &DNLoc,
8681 DeclarationName Name,
8682 const RecordData &Record, unsigned &Idx) {
8683 switch (Name.getNameKind()) {
8684 case DeclarationName::CXXConstructorName:
8685 case DeclarationName::CXXDestructorName:
8686 case DeclarationName::CXXConversionFunctionName:
8687 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
8688 break;
8689
8690 case DeclarationName::CXXOperatorName:
8691 DNLoc.CXXOperatorName.BeginOpNameLoc
8692 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8693 DNLoc.CXXOperatorName.EndOpNameLoc
8694 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8695 break;
8696
8697 case DeclarationName::CXXLiteralOperatorName:
8698 DNLoc.CXXLiteralOperatorName.OpNameLoc
8699 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
8700 break;
8701
8702 case DeclarationName::Identifier:
8703 case DeclarationName::ObjCZeroArgSelector:
8704 case DeclarationName::ObjCOneArgSelector:
8705 case DeclarationName::ObjCMultiArgSelector:
8706 case DeclarationName::CXXUsingDirective:
8707 case DeclarationName::CXXDeductionGuideName:
8708 break;
8709 }
8710}
8711
8712void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
8713 DeclarationNameInfo &NameInfo,
8714 const RecordData &Record, unsigned &Idx) {
8715 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
8716 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
8717 DeclarationNameLoc DNLoc;
8718 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
8719 NameInfo.setInfo(DNLoc);
8720}
8721
8722void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
8723 const RecordData &Record, unsigned &Idx) {
8724 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
8725 unsigned NumTPLists = Record[Idx++];
8726 Info.NumTemplParamLists = NumTPLists;
8727 if (NumTPLists) {
8728 Info.TemplParamLists =
8729 new (getContext()) TemplateParameterList *[NumTPLists];
8730 for (unsigned i = 0; i != NumTPLists; ++i)
8731 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
8732 }
8733}
8734
8735TemplateName
8736ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
8737 unsigned &Idx) {
8738 ASTContext &Context = getContext();
8739 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
8740 switch (Kind) {
8741 case TemplateName::Template:
8742 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
8743
8744 case TemplateName::OverloadedTemplate: {
8745 unsigned size = Record[Idx++];
8746 UnresolvedSet<8> Decls;
8747 while (size--)
8748 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
8749
8750 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
8751 }
8752
8753 case TemplateName::AssumedTemplate: {
8754 DeclarationName Name = ReadDeclarationName(F, Record, Idx);
8755 return Context.getAssumedTemplateName(Name);
8756 }
8757
8758 case TemplateName::QualifiedTemplate: {
8759 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8760 bool hasTemplKeyword = Record[Idx++];
8761 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
8762 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
8763 }
8764
8765 case TemplateName::DependentTemplate: {
8766 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
8767 if (Record[Idx++]) // isIdentifier
8768 return Context.getDependentTemplateName(NNS,
8769 GetIdentifierInfo(F, Record,
8770 Idx));
8771 return Context.getDependentTemplateName(NNS,
8772 (OverloadedOperatorKind)Record[Idx++]);
8773 }
8774
8775 case TemplateName::SubstTemplateTemplateParm: {
8776 TemplateTemplateParmDecl *param
8777 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8778 if (!param) return TemplateName();
8779 TemplateName replacement = ReadTemplateName(F, Record, Idx);
8780 return Context.getSubstTemplateTemplateParm(param, replacement);
8781 }
8782
8783 case TemplateName::SubstTemplateTemplateParmPack: {
8784 TemplateTemplateParmDecl *Param
8785 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
8786 if (!Param)
8787 return TemplateName();
8788
8789 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
8790 if (ArgPack.getKind() != TemplateArgument::Pack)
8791 return TemplateName();
8792
8793 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
8794 }
8795 }
8796
8797 llvm_unreachable("Unhandled template name kind!")::llvm::llvm_unreachable_internal("Unhandled template name kind!"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8797)
;
8798}
8799
8800TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
8801 const RecordData &Record,
8802 unsigned &Idx,
8803 bool Canonicalize) {
8804 ASTContext &Context = getContext();
8805 if (Canonicalize) {
8806 // The caller wants a canonical template argument. Sometimes the AST only
8807 // wants template arguments in canonical form (particularly as the template
8808 // argument lists of template specializations) so ensure we preserve that
8809 // canonical form across serialization.
8810 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
8811 return Context.getCanonicalTemplateArgument(Arg);
8812 }
8813
8814 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
8815 switch (Kind) {
8816 case TemplateArgument::Null:
8817 return TemplateArgument();
8818 case TemplateArgument::Type:
8819 return TemplateArgument(readType(F, Record, Idx));
8820 case TemplateArgument::Declaration: {
8821 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
8822 return TemplateArgument(D, readType(F, Record, Idx));
8823 }
8824 case TemplateArgument::NullPtr:
8825 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
8826 case TemplateArgument::Integral: {
8827 llvm::APSInt Value = ReadAPSInt(Record, Idx);
8828 QualType T = readType(F, Record, Idx);
8829 return TemplateArgument(Context, Value, T);
8830 }
8831 case TemplateArgument::Template:
8832 return TemplateArgument(ReadTemplateName(F, Record, Idx));
8833 case TemplateArgument::TemplateExpansion: {
8834 TemplateName Name = ReadTemplateName(F, Record, Idx);
8835 Optional<unsigned> NumTemplateExpansions;
8836 if (unsigned NumExpansions = Record[Idx++])
8837 NumTemplateExpansions = NumExpansions - 1;
8838 return TemplateArgument(Name, NumTemplateExpansions);
8839 }
8840 case TemplateArgument::Expression:
8841 return TemplateArgument(ReadExpr(F));
8842 case TemplateArgument::Pack: {
8843 unsigned NumArgs = Record[Idx++];
8844 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
8845 for (unsigned I = 0; I != NumArgs; ++I)
8846 Args[I] = ReadTemplateArgument(F, Record, Idx);
8847 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
8848 }
8849 }
8850
8851 llvm_unreachable("Unhandled template argument kind!")::llvm::llvm_unreachable_internal("Unhandled template argument kind!"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8851)
;
8852}
8853
8854TemplateParameterList *
8855ASTReader::ReadTemplateParameterList(ModuleFile &F,
8856 const RecordData &Record, unsigned &Idx) {
8857 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
8858 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
8859 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
8860
8861 unsigned NumParams = Record[Idx++];
8862 SmallVector<NamedDecl *, 16> Params;
8863 Params.reserve(NumParams);
8864 while (NumParams--)
8865 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
8866
8867 // TODO: Concepts
8868 TemplateParameterList *TemplateParams = TemplateParameterList::Create(
8869 getContext(), TemplateLoc, LAngleLoc, Params, RAngleLoc, nullptr);
8870 return TemplateParams;
8871}
8872
8873void
8874ASTReader::
8875ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
8876 ModuleFile &F, const RecordData &Record,
8877 unsigned &Idx, bool Canonicalize) {
8878 unsigned NumTemplateArgs = Record[Idx++];
8879 TemplArgs.reserve(NumTemplateArgs);
8880 while (NumTemplateArgs--)
8881 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
8882}
8883
8884/// Read a UnresolvedSet structure.
8885void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
8886 const RecordData &Record, unsigned &Idx) {
8887 unsigned NumDecls = Record[Idx++];
8888 Set.reserve(getContext(), NumDecls);
8889 while (NumDecls--) {
8890 DeclID ID = ReadDeclID(F, Record, Idx);
8891 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
8892 Set.addLazyDecl(getContext(), ID, AS);
8893 }
8894}
8895
8896CXXBaseSpecifier
8897ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
8898 const RecordData &Record, unsigned &Idx) {
8899 bool isVirtual = static_cast<bool>(Record[Idx++]);
8900 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
8901 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
8902 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
8903 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
8904 SourceRange Range = ReadSourceRange(F, Record, Idx);
8905 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
8906 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
8907 EllipsisLoc);
8908 Result.setInheritConstructors(inheritConstructors);
8909 return Result;
8910}
8911
8912CXXCtorInitializer **
8913ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
8914 unsigned &Idx) {
8915 ASTContext &Context = getContext();
8916 unsigned NumInitializers = Record[Idx++];
8917 assert(NumInitializers && "wrote ctor initializers but have no inits")((NumInitializers && "wrote ctor initializers but have no inits"
) ? static_cast<void> (0) : __assert_fail ("NumInitializers && \"wrote ctor initializers but have no inits\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 8917, __PRETTY_FUNCTION__))
;
8918 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
8919 for (unsigned i = 0; i != NumInitializers; ++i) {
8920 TypeSourceInfo *TInfo = nullptr;
8921 bool IsBaseVirtual = false;
8922 FieldDecl *Member = nullptr;
8923 IndirectFieldDecl *IndirectMember = nullptr;
8924
8925 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
8926 switch (Type) {
8927 case CTOR_INITIALIZER_BASE:
8928 TInfo = GetTypeSourceInfo(F, Record, Idx);
8929 IsBaseVirtual = Record[Idx++];
8930 break;
8931
8932 case CTOR_INITIALIZER_DELEGATING:
8933 TInfo = GetTypeSourceInfo(F, Record, Idx);
8934 break;
8935
8936 case CTOR_INITIALIZER_MEMBER:
8937 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
8938 break;
8939
8940 case CTOR_INITIALIZER_INDIRECT_MEMBER:
8941 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
8942 break;
8943 }
8944
8945 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
8946 Expr *Init = ReadExpr(F);
8947 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
8948 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
8949
8950 CXXCtorInitializer *BOMInit;
8951 if (Type == CTOR_INITIALIZER_BASE)
8952 BOMInit = new (Context)
8953 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8954 RParenLoc, MemberOrEllipsisLoc);
8955 else if (Type == CTOR_INITIALIZER_DELEGATING)
8956 BOMInit = new (Context)
8957 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8958 else if (Member)
8959 BOMInit = new (Context)
8960 CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, LParenLoc,
8961 Init, RParenLoc);
8962 else
8963 BOMInit = new (Context)
8964 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8965 LParenLoc, Init, RParenLoc);
8966
8967 if (/*IsWritten*/Record[Idx++]) {
8968 unsigned SourceOrder = Record[Idx++];
8969 BOMInit->setSourceOrder(SourceOrder);
8970 }
8971
8972 CtorInitializers[i] = BOMInit;
8973 }
8974
8975 return CtorInitializers;
8976}
8977
8978NestedNameSpecifier *
8979ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
8980 const RecordData &Record, unsigned &Idx) {
8981 ASTContext &Context = getContext();
8982 unsigned N = Record[Idx++];
8983 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8984 for (unsigned I = 0; I != N; ++I) {
8985 NestedNameSpecifier::SpecifierKind Kind
8986 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8987 switch (Kind) {
8988 case NestedNameSpecifier::Identifier: {
8989 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8990 NNS = NestedNameSpecifier::Create(Context, Prev, II);
8991 break;
8992 }
8993
8994 case NestedNameSpecifier::Namespace: {
8995 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8996 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8997 break;
8998 }
8999
9000 case NestedNameSpecifier::NamespaceAlias: {
9001 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9002 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
9003 break;
9004 }
9005
9006 case NestedNameSpecifier::TypeSpec:
9007 case NestedNameSpecifier::TypeSpecWithTemplate: {
9008 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
9009 if (!T)
9010 return nullptr;
9011
9012 bool Template = Record[Idx++];
9013 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
9014 break;
9015 }
9016
9017 case NestedNameSpecifier::Global:
9018 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
9019 // No associated value, and there can't be a prefix.
9020 break;
9021
9022 case NestedNameSpecifier::Super: {
9023 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9024 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
9025 break;
9026 }
9027 }
9028 Prev = NNS;
9029 }
9030 return NNS;
9031}
9032
9033NestedNameSpecifierLoc
9034ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
9035 unsigned &Idx) {
9036 ASTContext &Context = getContext();
9037 unsigned N = Record[Idx++];
9038 NestedNameSpecifierLocBuilder Builder;
9039 for (unsigned I = 0; I != N; ++I) {
9040 NestedNameSpecifier::SpecifierKind Kind
9041 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9042 switch (Kind) {
9043 case NestedNameSpecifier::Identifier: {
9044 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
9045 SourceRange Range = ReadSourceRange(F, Record, Idx);
9046 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
9047 break;
9048 }
9049
9050 case NestedNameSpecifier::Namespace: {
9051 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
9052 SourceRange Range = ReadSourceRange(F, Record, Idx);
9053 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
9054 break;
9055 }
9056
9057 case NestedNameSpecifier::NamespaceAlias: {
9058 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
9059 SourceRange Range = ReadSourceRange(F, Record, Idx);
9060 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
9061 break;
9062 }
9063
9064 case NestedNameSpecifier::TypeSpec:
9065 case NestedNameSpecifier::TypeSpecWithTemplate: {
9066 bool Template = Record[Idx++];
9067 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
9068 if (!T)
9069 return NestedNameSpecifierLoc();
9070 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9071
9072 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
9073 Builder.Extend(Context,
9074 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
9075 T->getTypeLoc(), ColonColonLoc);
9076 break;
9077 }
9078
9079 case NestedNameSpecifier::Global: {
9080 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
9081 Builder.MakeGlobal(Context, ColonColonLoc);
9082 break;
9083 }
9084
9085 case NestedNameSpecifier::Super: {
9086 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
9087 SourceRange Range = ReadSourceRange(F, Record, Idx);
9088 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
9089 break;
9090 }
9091 }
9092 }
9093
9094 return Builder.getWithLocInContext(Context);
9095}
9096
9097SourceRange
9098ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
9099 unsigned &Idx) {
9100 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
9101 SourceLocation end = ReadSourceLocation(F, Record, Idx);
9102 return SourceRange(beg, end);
9103}
9104
9105/// Read an integral value
9106llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
9107 unsigned BitWidth = Record[Idx++];
9108 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
9109 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
9110 Idx += NumWords;
9111 return Result;
9112}
9113
9114/// Read a signed integral value
9115llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
9116 bool isUnsigned = Record[Idx++];
9117 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
9118}
9119
9120/// Read a floating-point value
9121llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
9122 const llvm::fltSemantics &Sem,
9123 unsigned &Idx) {
9124 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
9125}
9126
9127// Read a string
9128std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
9129 unsigned Len = Record[Idx++];
9130 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
9131 Idx += Len;
9132 return Result;
9133}
9134
9135std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
9136 unsigned &Idx) {
9137 std::string Filename = ReadString(Record, Idx);
9138 ResolveImportedPath(F, Filename);
9139 return Filename;
9140}
9141
9142std::string ASTReader::ReadPath(StringRef BaseDirectory,
9143 const RecordData &Record, unsigned &Idx) {
9144 std::string Filename = ReadString(Record, Idx);
9145 if (!BaseDirectory.empty())
9146 ResolveImportedPath(Filename, BaseDirectory);
9147 return Filename;
9148}
9149
9150VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
9151 unsigned &Idx) {
9152 unsigned Major = Record[Idx++];
9153 unsigned Minor = Record[Idx++];
9154 unsigned Subminor = Record[Idx++];
9155 if (Minor == 0)
9156 return VersionTuple(Major);
9157 if (Subminor == 0)
9158 return VersionTuple(Major, Minor - 1);
9159 return VersionTuple(Major, Minor - 1, Subminor - 1);
9160}
9161
9162CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
9163 const RecordData &Record,
9164 unsigned &Idx) {
9165 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
9166 return CXXTemporary::Create(getContext(), Decl);
9167}
9168
9169DiagnosticBuilder ASTReader::Diag(unsigned DiagID) const {
9170 return Diag(CurrentImportLoc, DiagID);
9171}
9172
9173DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) const {
9174 return Diags.Report(Loc, DiagID);
9175}
9176
9177/// Retrieve the identifier table associated with the
9178/// preprocessor.
9179IdentifierTable &ASTReader::getIdentifierTable() {
9180 return PP.getIdentifierTable();
9181}
9182
9183/// Record that the given ID maps to the given switch-case
9184/// statement.
9185void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
9186 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&(((*CurrSwitchCaseStmts)[ID] == nullptr && "Already have a SwitchCase with this ID"
) ? static_cast<void> (0) : __assert_fail ("(*CurrSwitchCaseStmts)[ID] == nullptr && \"Already have a SwitchCase with this ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9187, __PRETTY_FUNCTION__))
9187 "Already have a SwitchCase with this ID")(((*CurrSwitchCaseStmts)[ID] == nullptr && "Already have a SwitchCase with this ID"
) ? static_cast<void> (0) : __assert_fail ("(*CurrSwitchCaseStmts)[ID] == nullptr && \"Already have a SwitchCase with this ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9187, __PRETTY_FUNCTION__))
;
9188 (*CurrSwitchCaseStmts)[ID] = SC;
9189}
9190
9191/// Retrieve the switch-case statement with the given ID.
9192SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
9193 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID")(((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID"
) ? static_cast<void> (0) : __assert_fail ("(*CurrSwitchCaseStmts)[ID] != nullptr && \"No SwitchCase with this ID\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9193, __PRETTY_FUNCTION__))
;
9194 return (*CurrSwitchCaseStmts)[ID];
9195}
9196
9197void ASTReader::ClearSwitchCaseIDs() {
9198 CurrSwitchCaseStmts->clear();
9199}
9200
9201void ASTReader::ReadComments() {
9202 ASTContext &Context = getContext();
9203 std::vector<RawComment *> Comments;
9204 for (SmallVectorImpl<std::pair<BitstreamCursor,
9205 serialization::ModuleFile *>>::iterator
9206 I = CommentsCursors.begin(),
9207 E = CommentsCursors.end();
9208 I != E; ++I) {
9209 Comments.clear();
9210 BitstreamCursor &Cursor = I->first;
9211 serialization::ModuleFile &F = *I->second;
9212 SavedStreamPosition SavedPosition(Cursor);
9213
9214 RecordData Record;
9215 while (true) {
9216 llvm::BitstreamEntry Entry =
9217 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
9218
9219 switch (Entry.Kind) {
9220 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
9221 case llvm::BitstreamEntry::Error:
9222 Error("malformed block record in AST file");
9223 return;
9224 case llvm::BitstreamEntry::EndBlock:
9225 goto NextCursor;
9226 case llvm::BitstreamEntry::Record:
9227 // The interesting case.
9228 break;
9229 }
9230
9231 // Read a record.
9232 Record.clear();
9233 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
9234 case COMMENTS_RAW_COMMENT: {
9235 unsigned Idx = 0;
9236 SourceRange SR = ReadSourceRange(F, Record, Idx);
9237 RawComment::CommentKind Kind =
9238 (RawComment::CommentKind) Record[Idx++];
9239 bool IsTrailingComment = Record[Idx++];
9240 bool IsAlmostTrailingComment = Record[Idx++];
9241 Comments.push_back(new (Context) RawComment(
9242 SR, Kind, IsTrailingComment, IsAlmostTrailingComment));
9243 break;
9244 }
9245 }
9246 }
9247 NextCursor:
9248 // De-serialized SourceLocations get negative FileIDs for other modules,
9249 // potentially invalidating the original order. Sort it again.
9250 llvm::sort(Comments, BeforeThanCompare<RawComment>(SourceMgr));
9251 Context.Comments.addDeserializedComments(Comments);
9252 }
9253}
9254
9255void ASTReader::visitInputFiles(serialization::ModuleFile &MF,
9256 bool IncludeSystem, bool Complain,
9257 llvm::function_ref<void(const serialization::InputFile &IF,
9258 bool isSystem)> Visitor) {
9259 unsigned NumUserInputs = MF.NumUserInputFiles;
9260 unsigned NumInputs = MF.InputFilesLoaded.size();
9261 assert(NumUserInputs <= NumInputs)((NumUserInputs <= NumInputs) ? static_cast<void> (0
) : __assert_fail ("NumUserInputs <= NumInputs", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9261, __PRETTY_FUNCTION__))
;
9262 unsigned N = IncludeSystem ? NumInputs : NumUserInputs;
9263 for (unsigned I = 0; I < N; ++I) {
9264 bool IsSystem = I >= NumUserInputs;
9265 InputFile IF = getInputFile(MF, I+1, Complain);
9266 Visitor(IF, IsSystem);
9267 }
9268}
9269
9270void ASTReader::visitTopLevelModuleMaps(
9271 serialization::ModuleFile &MF,
9272 llvm::function_ref<void(const FileEntry *FE)> Visitor) {
9273 unsigned NumInputs = MF.InputFilesLoaded.size();
9274 for (unsigned I = 0; I < NumInputs; ++I) {
1
Assuming 'I' is < 'NumInputs'
2
Loop condition is true. Entering loop body
9275 InputFileInfo IFI = readInputFileInfo(MF, I + 1);
3
Calling 'ASTReader::readInputFileInfo'
9276 if (IFI.TopLevelModuleMap)
9277 // FIXME: This unnecessarily re-reads the InputFileInfo.
9278 if (auto *FE = getInputFile(MF, I + 1).getFile())
9279 Visitor(FE);
9280 }
9281}
9282
9283std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
9284 // If we know the owning module, use it.
9285 if (Module *M = D->getImportedOwningModule())
9286 return M->getFullModuleName();
9287
9288 // Otherwise, use the name of the top-level module the decl is within.
9289 if (ModuleFile *M = getOwningModuleFile(D))
9290 return M->ModuleName;
9291
9292 // Not from a module.
9293 return {};
9294}
9295
9296void ASTReader::finishPendingActions() {
9297 while (!PendingIdentifierInfos.empty() || !PendingFunctionTypes.empty() ||
9298 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
9299 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
9300 !PendingUpdateRecords.empty()) {
9301 // If any identifiers with corresponding top-level declarations have
9302 // been loaded, load those declarations now.
9303 using TopLevelDeclsMap =
9304 llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2>>;
9305 TopLevelDeclsMap TopLevelDecls;
9306
9307 while (!PendingIdentifierInfos.empty()) {
9308 IdentifierInfo *II = PendingIdentifierInfos.back().first;
9309 SmallVector<uint32_t, 4> DeclIDs =
9310 std::move(PendingIdentifierInfos.back().second);
9311 PendingIdentifierInfos.pop_back();
9312
9313 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
9314 }
9315
9316 // Load each function type that we deferred loading because it was a
9317 // deduced type that might refer to a local type declared within itself.
9318 for (unsigned I = 0; I != PendingFunctionTypes.size(); ++I) {
9319 auto *FD = PendingFunctionTypes[I].first;
9320 FD->setType(GetType(PendingFunctionTypes[I].second));
9321
9322 // If we gave a function a deduced return type, remember that we need to
9323 // propagate that along the redeclaration chain.
9324 auto *DT = FD->getReturnType()->getContainedDeducedType();
9325 if (DT && DT->isDeduced())
9326 PendingDeducedTypeUpdates.insert(
9327 {FD->getCanonicalDecl(), FD->getReturnType()});
9328 }
9329 PendingFunctionTypes.clear();
9330
9331 // For each decl chain that we wanted to complete while deserializing, mark
9332 // it as "still needs to be completed".
9333 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
9334 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
9335 }
9336 PendingIncompleteDeclChains.clear();
9337
9338 // Load pending declaration chains.
9339 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
9340 loadPendingDeclChain(PendingDeclChains[I].first,
9341 PendingDeclChains[I].second);
9342 PendingDeclChains.clear();
9343
9344 // Make the most recent of the top-level declarations visible.
9345 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
9346 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
9347 IdentifierInfo *II = TLD->first;
9348 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
9349 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
9350 }
9351 }
9352
9353 // Load any pending macro definitions.
9354 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
9355 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
9356 SmallVector<PendingMacroInfo, 2> GlobalIDs;
9357 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
9358 // Initialize the macro history from chained-PCHs ahead of module imports.
9359 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9360 ++IDIdx) {
9361 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9362 if (!Info.M->isModule())
9363 resolvePendingMacro(II, Info);
9364 }
9365 // Handle module imports.
9366 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
9367 ++IDIdx) {
9368 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
9369 if (Info.M->isModule())
9370 resolvePendingMacro(II, Info);
9371 }
9372 }
9373 PendingMacroIDs.clear();
9374
9375 // Wire up the DeclContexts for Decls that we delayed setting until
9376 // recursive loading is completed.
9377 while (!PendingDeclContextInfos.empty()) {
9378 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
9379 PendingDeclContextInfos.pop_front();
9380 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
9381 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
9382 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
9383 }
9384
9385 // Perform any pending declaration updates.
9386 while (!PendingUpdateRecords.empty()) {
9387 auto Update = PendingUpdateRecords.pop_back_val();
9388 ReadingKindTracker ReadingKind(Read_Decl, *this);
9389 loadDeclUpdateRecords(Update);
9390 }
9391 }
9392
9393 // At this point, all update records for loaded decls are in place, so any
9394 // fake class definitions should have become real.
9395 assert(PendingFakeDefinitionData.empty() &&((PendingFakeDefinitionData.empty() && "faked up a class definition but never saw the real one"
) ? static_cast<void> (0) : __assert_fail ("PendingFakeDefinitionData.empty() && \"faked up a class definition but never saw the real one\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9396, __PRETTY_FUNCTION__))
9396 "faked up a class definition but never saw the real one")((PendingFakeDefinitionData.empty() && "faked up a class definition but never saw the real one"
) ? static_cast<void> (0) : __assert_fail ("PendingFakeDefinitionData.empty() && \"faked up a class definition but never saw the real one\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9396, __PRETTY_FUNCTION__))
;
9397
9398 // If we deserialized any C++ or Objective-C class definitions, any
9399 // Objective-C protocol definitions, or any redeclarable templates, make sure
9400 // that all redeclarations point to the definitions. Note that this can only
9401 // happen now, after the redeclaration chains have been fully wired.
9402 for (Decl *D : PendingDefinitions) {
9403 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
9404 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
9405 // Make sure that the TagType points at the definition.
9406 const_cast<TagType*>(TagT)->decl = TD;
9407 }
9408
9409 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
9410 for (auto *R = getMostRecentExistingDecl(RD); R;
9411 R = R->getPreviousDecl()) {
9412 assert((R == D) ==(((R == D) == cast<CXXRecordDecl>(R)->isThisDeclarationADefinition
() && "declaration thinks it's the definition but it isn't"
) ? static_cast<void> (0) : __assert_fail ("(R == D) == cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() && \"declaration thinks it's the definition but it isn't\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9414, __PRETTY_FUNCTION__))
9413 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&(((R == D) == cast<CXXRecordDecl>(R)->isThisDeclarationADefinition
() && "declaration thinks it's the definition but it isn't"
) ? static_cast<void> (0) : __assert_fail ("(R == D) == cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() && \"declaration thinks it's the definition but it isn't\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9414, __PRETTY_FUNCTION__))
9414 "declaration thinks it's the definition but it isn't")(((R == D) == cast<CXXRecordDecl>(R)->isThisDeclarationADefinition
() && "declaration thinks it's the definition but it isn't"
) ? static_cast<void> (0) : __assert_fail ("(R == D) == cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() && \"declaration thinks it's the definition but it isn't\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9414, __PRETTY_FUNCTION__))
;
9415 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
9416 }
9417 }
9418
9419 continue;
9420 }
9421
9422 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
9423 // Make sure that the ObjCInterfaceType points at the definition.
9424 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
9425 ->Decl = ID;
9426
9427 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
9428 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
9429
9430 continue;
9431 }
9432
9433 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
9434 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
9435 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
9436
9437 continue;
9438 }
9439
9440 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
9441 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
9442 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
9443 }
9444 PendingDefinitions.clear();
9445
9446 // Load the bodies of any functions or methods we've encountered. We do
9447 // this now (delayed) so that we can be sure that the declaration chains
9448 // have been fully wired up (hasBody relies on this).
9449 // FIXME: We shouldn't require complete redeclaration chains here.
9450 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
9451 PBEnd = PendingBodies.end();
9452 PB != PBEnd; ++PB) {
9453 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
9454 // For a function defined inline within a class template, force the
9455 // canonical definition to be the one inside the canonical definition of
9456 // the template. This ensures that we instantiate from a correct view
9457 // of the template.
9458 //
9459 // Sadly we can't do this more generally: we can't be sure that all
9460 // copies of an arbitrary class definition will have the same members
9461 // defined (eg, some member functions may not be instantiated, and some
9462 // special members may or may not have been implicitly defined).
9463 if (auto *RD = dyn_cast<CXXRecordDecl>(FD->getLexicalParent()))
9464 if (RD->isDependentContext() && !RD->isThisDeclarationADefinition())
9465 continue;
9466
9467 // FIXME: Check for =delete/=default?
9468 // FIXME: Complain about ODR violations here?
9469 const FunctionDecl *Defn = nullptr;
9470 if (!getContext().getLangOpts().Modules || !FD->hasBody(Defn)) {
9471 FD->setLazyBody(PB->second);
9472 } else {
9473 auto *NonConstDefn = const_cast<FunctionDecl*>(Defn);
9474 mergeDefinitionVisibility(NonConstDefn, FD);
9475
9476 if (!FD->isLateTemplateParsed() &&
9477 !NonConstDefn->isLateTemplateParsed() &&
9478 FD->getODRHash() != NonConstDefn->getODRHash()) {
9479 if (!isa<CXXMethodDecl>(FD)) {
9480 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9481 } else if (FD->getLexicalParent()->isFileContext() &&
9482 NonConstDefn->getLexicalParent()->isFileContext()) {
9483 // Only diagnose out-of-line method definitions. If they are
9484 // in class definitions, then an error will be generated when
9485 // processing the class bodies.
9486 PendingFunctionOdrMergeFailures[FD].push_back(NonConstDefn);
9487 }
9488 }
9489 }
9490 continue;
9491 }
9492
9493 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
9494 if (!getContext().getLangOpts().Modules || !MD->hasBody())
9495 MD->setLazyBody(PB->second);
9496 }
9497 PendingBodies.clear();
9498
9499 // Do some cleanup.
9500 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
9501 getContext().deduplicateMergedDefinitonsFor(ND);
9502 PendingMergedDefinitionsToDeduplicate.clear();
9503}
9504
9505void ASTReader::diagnoseOdrViolations() {
9506 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty() &&
9507 PendingFunctionOdrMergeFailures.empty() &&
9508 PendingEnumOdrMergeFailures.empty())
9509 return;
9510
9511 // Trigger the import of the full definition of each class that had any
9512 // odr-merging problems, so we can produce better diagnostics for them.
9513 // These updates may in turn find and diagnose some ODR failures, so take
9514 // ownership of the set first.
9515 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
9516 PendingOdrMergeFailures.clear();
9517 for (auto &Merge : OdrMergeFailures) {
9518 Merge.first->buildLookup();
9519 Merge.first->decls_begin();
9520 Merge.first->bases_begin();
9521 Merge.first->vbases_begin();
9522 for (auto &RecordPair : Merge.second) {
9523 auto *RD = RecordPair.first;
9524 RD->decls_begin();
9525 RD->bases_begin();
9526 RD->vbases_begin();
9527 }
9528 }
9529
9530 // Trigger the import of functions.
9531 auto FunctionOdrMergeFailures = std::move(PendingFunctionOdrMergeFailures);
9532 PendingFunctionOdrMergeFailures.clear();
9533 for (auto &Merge : FunctionOdrMergeFailures) {
9534 Merge.first->buildLookup();
9535 Merge.first->decls_begin();
9536 Merge.first->getBody();
9537 for (auto &FD : Merge.second) {
9538 FD->buildLookup();
9539 FD->decls_begin();
9540 FD->getBody();
9541 }
9542 }
9543
9544 // Trigger the import of enums.
9545 auto EnumOdrMergeFailures = std::move(PendingEnumOdrMergeFailures);
9546 PendingEnumOdrMergeFailures.clear();
9547 for (auto &Merge : EnumOdrMergeFailures) {
9548 Merge.first->decls_begin();
9549 for (auto &Enum : Merge.second) {
9550 Enum->decls_begin();
9551 }
9552 }
9553
9554 // For each declaration from a merged context, check that the canonical
9555 // definition of that context also contains a declaration of the same
9556 // entity.
9557 //
9558 // Caution: this loop does things that might invalidate iterators into
9559 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
9560 while (!PendingOdrMergeChecks.empty()) {
9561 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
9562
9563 // FIXME: Skip over implicit declarations for now. This matters for things
9564 // like implicitly-declared special member functions. This isn't entirely
9565 // correct; we can end up with multiple unmerged declarations of the same
9566 // implicit entity.
9567 if (D->isImplicit())
9568 continue;
9569
9570 DeclContext *CanonDef = D->getDeclContext();
9571
9572 bool Found = false;
9573 const Decl *DCanon = D->getCanonicalDecl();
9574
9575 for (auto RI : D->redecls()) {
9576 if (RI->getLexicalDeclContext() == CanonDef) {
9577 Found = true;
9578 break;
9579 }
9580 }
9581 if (Found)
9582 continue;
9583
9584 // Quick check failed, time to do the slow thing. Note, we can't just
9585 // look up the name of D in CanonDef here, because the member that is
9586 // in CanonDef might not be found by name lookup (it might have been
9587 // replaced by a more recent declaration in the lookup table), and we
9588 // can't necessarily find it in the redeclaration chain because it might
9589 // be merely mergeable, not redeclarable.
9590 llvm::SmallVector<const NamedDecl*, 4> Candidates;
9591 for (auto *CanonMember : CanonDef->decls()) {
9592 if (CanonMember->getCanonicalDecl() == DCanon) {
9593 // This can happen if the declaration is merely mergeable and not
9594 // actually redeclarable (we looked for redeclarations earlier).
9595 //
9596 // FIXME: We should be able to detect this more efficiently, without
9597 // pulling in all of the members of CanonDef.
9598 Found = true;
9599 break;
9600 }
9601 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
9602 if (ND->getDeclName() == D->getDeclName())
9603 Candidates.push_back(ND);
9604 }
9605
9606 if (!Found) {
9607 // The AST doesn't like TagDecls becoming invalid after they've been
9608 // completed. We only really need to mark FieldDecls as invalid here.
9609 if (!isa<TagDecl>(D))
9610 D->setInvalidDecl();
9611
9612 // Ensure we don't accidentally recursively enter deserialization while
9613 // we're producing our diagnostic.
9614 Deserializing RecursionGuard(this);
9615
9616 std::string CanonDefModule =
9617 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
9618 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
9619 << D << getOwningModuleNameForDiagnostic(D)
9620 << CanonDef << CanonDefModule.empty() << CanonDefModule;
9621
9622 if (Candidates.empty())
9623 Diag(cast<Decl>(CanonDef)->getLocation(),
9624 diag::note_module_odr_violation_no_possible_decls) << D;
9625 else {
9626 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
9627 Diag(Candidates[I]->getLocation(),
9628 diag::note_module_odr_violation_possible_decl)
9629 << Candidates[I];
9630 }
9631
9632 DiagnosedOdrMergeFailures.insert(CanonDef);
9633 }
9634 }
9635
9636 if (OdrMergeFailures.empty() && FunctionOdrMergeFailures.empty() &&
9637 EnumOdrMergeFailures.empty())
9638 return;
9639
9640 // Ensure we don't accidentally recursively enter deserialization while
9641 // we're producing our diagnostics.
9642 Deserializing RecursionGuard(this);
9643
9644 // Common code for hashing helpers.
9645 ODRHash Hash;
9646 auto ComputeQualTypeODRHash = [&Hash](QualType Ty) {
9647 Hash.clear();
9648 Hash.AddQualType(Ty);
9649 return Hash.CalculateHash();
9650 };
9651
9652 auto ComputeODRHash = [&Hash](const Stmt *S) {
9653 assert(S)((S) ? static_cast<void> (0) : __assert_fail ("S", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9653, __PRETTY_FUNCTION__))
;
9654 Hash.clear();
9655 Hash.AddStmt(S);
9656 return Hash.CalculateHash();
9657 };
9658
9659 auto ComputeSubDeclODRHash = [&Hash](const Decl *D) {
9660 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9660, __PRETTY_FUNCTION__))
;
9661 Hash.clear();
9662 Hash.AddSubDecl(D);
9663 return Hash.CalculateHash();
9664 };
9665
9666 auto ComputeTemplateArgumentODRHash = [&Hash](const TemplateArgument &TA) {
9667 Hash.clear();
9668 Hash.AddTemplateArgument(TA);
9669 return Hash.CalculateHash();
9670 };
9671
9672 auto ComputeTemplateParameterListODRHash =
9673 [&Hash](const TemplateParameterList *TPL) {
9674 assert(TPL)((TPL) ? static_cast<void> (0) : __assert_fail ("TPL", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9674, __PRETTY_FUNCTION__))
;
9675 Hash.clear();
9676 Hash.AddTemplateParameterList(TPL);
9677 return Hash.CalculateHash();
9678 };
9679
9680 // Issue any pending ODR-failure diagnostics.
9681 for (auto &Merge : OdrMergeFailures) {
9682 // If we've already pointed out a specific problem with this class, don't
9683 // bother issuing a general "something's different" diagnostic.
9684 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
9685 continue;
9686
9687 bool Diagnosed = false;
9688 CXXRecordDecl *FirstRecord = Merge.first;
9689 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstRecord);
9690 for (auto &RecordPair : Merge.second) {
9691 CXXRecordDecl *SecondRecord = RecordPair.first;
9692 // Multiple different declarations got merged together; tell the user
9693 // where they came from.
9694 if (FirstRecord == SecondRecord)
9695 continue;
9696
9697 std::string SecondModule = getOwningModuleNameForDiagnostic(SecondRecord);
9698
9699 auto *FirstDD = FirstRecord->DefinitionData;
9700 auto *SecondDD = RecordPair.second;
9701
9702 assert(FirstDD && SecondDD && "Definitions without DefinitionData")((FirstDD && SecondDD && "Definitions without DefinitionData"
) ? static_cast<void> (0) : __assert_fail ("FirstDD && SecondDD && \"Definitions without DefinitionData\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9702, __PRETTY_FUNCTION__))
;
9703
9704 // Diagnostics from DefinitionData are emitted here.
9705 if (FirstDD != SecondDD) {
9706 enum ODRDefinitionDataDifference {
9707 NumBases,
9708 NumVBases,
9709 BaseType,
9710 BaseVirtual,
9711 BaseAccess,
9712 };
9713 auto ODRDiagError = [FirstRecord, &FirstModule,
9714 this](SourceLocation Loc, SourceRange Range,
9715 ODRDefinitionDataDifference DiffType) {
9716 return Diag(Loc, diag::err_module_odr_violation_definition_data)
9717 << FirstRecord << FirstModule.empty() << FirstModule << Range
9718 << DiffType;
9719 };
9720 auto ODRDiagNote = [&SecondModule,
9721 this](SourceLocation Loc, SourceRange Range,
9722 ODRDefinitionDataDifference DiffType) {
9723 return Diag(Loc, diag::note_module_odr_violation_definition_data)
9724 << SecondModule << Range << DiffType;
9725 };
9726
9727 unsigned FirstNumBases = FirstDD->NumBases;
9728 unsigned FirstNumVBases = FirstDD->NumVBases;
9729 unsigned SecondNumBases = SecondDD->NumBases;
9730 unsigned SecondNumVBases = SecondDD->NumVBases;
9731
9732 auto GetSourceRange = [](struct CXXRecordDecl::DefinitionData *DD) {
9733 unsigned NumBases = DD->NumBases;
9734 if (NumBases == 0) return SourceRange();
9735 auto bases = DD->bases();
9736 return SourceRange(bases[0].getBeginLoc(),
9737 bases[NumBases - 1].getEndLoc());
9738 };
9739
9740 if (FirstNumBases != SecondNumBases) {
9741 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9742 NumBases)
9743 << FirstNumBases;
9744 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9745 NumBases)
9746 << SecondNumBases;
9747 Diagnosed = true;
9748 break;
9749 }
9750
9751 if (FirstNumVBases != SecondNumVBases) {
9752 ODRDiagError(FirstRecord->getLocation(), GetSourceRange(FirstDD),
9753 NumVBases)
9754 << FirstNumVBases;
9755 ODRDiagNote(SecondRecord->getLocation(), GetSourceRange(SecondDD),
9756 NumVBases)
9757 << SecondNumVBases;
9758 Diagnosed = true;
9759 break;
9760 }
9761
9762 auto FirstBases = FirstDD->bases();
9763 auto SecondBases = SecondDD->bases();
9764 unsigned i = 0;
9765 for (i = 0; i < FirstNumBases; ++i) {
9766 auto FirstBase = FirstBases[i];
9767 auto SecondBase = SecondBases[i];
9768 if (ComputeQualTypeODRHash(FirstBase.getType()) !=
9769 ComputeQualTypeODRHash(SecondBase.getType())) {
9770 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9771 BaseType)
9772 << (i + 1) << FirstBase.getType();
9773 ODRDiagNote(SecondRecord->getLocation(),
9774 SecondBase.getSourceRange(), BaseType)
9775 << (i + 1) << SecondBase.getType();
9776 break;
9777 }
9778
9779 if (FirstBase.isVirtual() != SecondBase.isVirtual()) {
9780 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9781 BaseVirtual)
9782 << (i + 1) << FirstBase.isVirtual() << FirstBase.getType();
9783 ODRDiagNote(SecondRecord->getLocation(),
9784 SecondBase.getSourceRange(), BaseVirtual)
9785 << (i + 1) << SecondBase.isVirtual() << SecondBase.getType();
9786 break;
9787 }
9788
9789 if (FirstBase.getAccessSpecifierAsWritten() !=
9790 SecondBase.getAccessSpecifierAsWritten()) {
9791 ODRDiagError(FirstRecord->getLocation(), FirstBase.getSourceRange(),
9792 BaseAccess)
9793 << (i + 1) << FirstBase.getType()
9794 << (int)FirstBase.getAccessSpecifierAsWritten();
9795 ODRDiagNote(SecondRecord->getLocation(),
9796 SecondBase.getSourceRange(), BaseAccess)
9797 << (i + 1) << SecondBase.getType()
9798 << (int)SecondBase.getAccessSpecifierAsWritten();
9799 break;
9800 }
9801 }
9802
9803 if (i != FirstNumBases) {
9804 Diagnosed = true;
9805 break;
9806 }
9807 }
9808
9809 using DeclHashes = llvm::SmallVector<std::pair<Decl *, unsigned>, 4>;
9810
9811 const ClassTemplateDecl *FirstTemplate =
9812 FirstRecord->getDescribedClassTemplate();
9813 const ClassTemplateDecl *SecondTemplate =
9814 SecondRecord->getDescribedClassTemplate();
9815
9816 assert(!FirstTemplate == !SecondTemplate &&((!FirstTemplate == !SecondTemplate && "Both pointers should be null or non-null"
) ? static_cast<void> (0) : __assert_fail ("!FirstTemplate == !SecondTemplate && \"Both pointers should be null or non-null\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9817, __PRETTY_FUNCTION__))
9817 "Both pointers should be null or non-null")((!FirstTemplate == !SecondTemplate && "Both pointers should be null or non-null"
) ? static_cast<void> (0) : __assert_fail ("!FirstTemplate == !SecondTemplate && \"Both pointers should be null or non-null\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9817, __PRETTY_FUNCTION__))
;
9818
9819 enum ODRTemplateDifference {
9820 ParamEmptyName,
9821 ParamName,
9822 ParamSingleDefaultArgument,
9823 ParamDifferentDefaultArgument,
9824 };
9825
9826 if (FirstTemplate && SecondTemplate) {
9827 DeclHashes FirstTemplateHashes;
9828 DeclHashes SecondTemplateHashes;
9829
9830 auto PopulateTemplateParameterHashs =
9831 [&ComputeSubDeclODRHash](DeclHashes &Hashes,
9832 const ClassTemplateDecl *TD) {
9833 for (auto *D : TD->getTemplateParameters()->asArray()) {
9834 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
9835 }
9836 };
9837
9838 PopulateTemplateParameterHashs(FirstTemplateHashes, FirstTemplate);
9839 PopulateTemplateParameterHashs(SecondTemplateHashes, SecondTemplate);
9840
9841 assert(FirstTemplateHashes.size() == SecondTemplateHashes.size() &&((FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
"Number of template parameters should be equal.") ? static_cast
<void> (0) : __assert_fail ("FirstTemplateHashes.size() == SecondTemplateHashes.size() && \"Number of template parameters should be equal.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9842, __PRETTY_FUNCTION__))
9842 "Number of template parameters should be equal.")((FirstTemplateHashes.size() == SecondTemplateHashes.size() &&
"Number of template parameters should be equal.") ? static_cast
<void> (0) : __assert_fail ("FirstTemplateHashes.size() == SecondTemplateHashes.size() && \"Number of template parameters should be equal.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9842, __PRETTY_FUNCTION__))
;
9843
9844 auto FirstIt = FirstTemplateHashes.begin();
9845 auto FirstEnd = FirstTemplateHashes.end();
9846 auto SecondIt = SecondTemplateHashes.begin();
9847 for (; FirstIt != FirstEnd; ++FirstIt, ++SecondIt) {
9848 if (FirstIt->second == SecondIt->second)
9849 continue;
9850
9851 auto ODRDiagError = [FirstRecord, &FirstModule,
9852 this](SourceLocation Loc, SourceRange Range,
9853 ODRTemplateDifference DiffType) {
9854 return Diag(Loc, diag::err_module_odr_violation_template_parameter)
9855 << FirstRecord << FirstModule.empty() << FirstModule << Range
9856 << DiffType;
9857 };
9858 auto ODRDiagNote = [&SecondModule,
9859 this](SourceLocation Loc, SourceRange Range,
9860 ODRTemplateDifference DiffType) {
9861 return Diag(Loc, diag::note_module_odr_violation_template_parameter)
9862 << SecondModule << Range << DiffType;
9863 };
9864
9865 const NamedDecl* FirstDecl = cast<NamedDecl>(FirstIt->first);
9866 const NamedDecl* SecondDecl = cast<NamedDecl>(SecondIt->first);
9867
9868 assert(FirstDecl->getKind() == SecondDecl->getKind() &&((FirstDecl->getKind() == SecondDecl->getKind() &&
"Parameter Decl's should be the same kind.") ? static_cast<
void> (0) : __assert_fail ("FirstDecl->getKind() == SecondDecl->getKind() && \"Parameter Decl's should be the same kind.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9869, __PRETTY_FUNCTION__))
9869 "Parameter Decl's should be the same kind.")((FirstDecl->getKind() == SecondDecl->getKind() &&
"Parameter Decl's should be the same kind.") ? static_cast<
void> (0) : __assert_fail ("FirstDecl->getKind() == SecondDecl->getKind() && \"Parameter Decl's should be the same kind.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9869, __PRETTY_FUNCTION__))
;
9870
9871 DeclarationName FirstName = FirstDecl->getDeclName();
9872 DeclarationName SecondName = SecondDecl->getDeclName();
9873
9874 if (FirstName != SecondName) {
9875 const bool FirstNameEmpty =
9876 FirstName.isIdentifier() && !FirstName.getAsIdentifierInfo();
9877 const bool SecondNameEmpty =
9878 SecondName.isIdentifier() && !SecondName.getAsIdentifierInfo();
9879 assert((!FirstNameEmpty || !SecondNameEmpty) &&(((!FirstNameEmpty || !SecondNameEmpty) && "Both template parameters cannot be unnamed."
) ? static_cast<void> (0) : __assert_fail ("(!FirstNameEmpty || !SecondNameEmpty) && \"Both template parameters cannot be unnamed.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9880, __PRETTY_FUNCTION__))
9880 "Both template parameters cannot be unnamed.")(((!FirstNameEmpty || !SecondNameEmpty) && "Both template parameters cannot be unnamed."
) ? static_cast<void> (0) : __assert_fail ("(!FirstNameEmpty || !SecondNameEmpty) && \"Both template parameters cannot be unnamed.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9880, __PRETTY_FUNCTION__))
;
9881 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9882 FirstNameEmpty ? ParamEmptyName : ParamName)
9883 << FirstName;
9884 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9885 SecondNameEmpty ? ParamEmptyName : ParamName)
9886 << SecondName;
9887 break;
9888 }
9889
9890 switch (FirstDecl->getKind()) {
9891 default:
9892 llvm_unreachable("Invalid template parameter type.")::llvm::llvm_unreachable_internal("Invalid template parameter type."
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9892)
;
9893 case Decl::TemplateTypeParm: {
9894 const auto *FirstParam = cast<TemplateTypeParmDecl>(FirstDecl);
9895 const auto *SecondParam = cast<TemplateTypeParmDecl>(SecondDecl);
9896 const bool HasFirstDefaultArgument =
9897 FirstParam->hasDefaultArgument() &&
9898 !FirstParam->defaultArgumentWasInherited();
9899 const bool HasSecondDefaultArgument =
9900 SecondParam->hasDefaultArgument() &&
9901 !SecondParam->defaultArgumentWasInherited();
9902
9903 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9904 ODRDiagError(FirstDecl->getLocation(),
9905 FirstDecl->getSourceRange(),
9906 ParamSingleDefaultArgument)
9907 << HasFirstDefaultArgument;
9908 ODRDiagNote(SecondDecl->getLocation(),
9909 SecondDecl->getSourceRange(),
9910 ParamSingleDefaultArgument)
9911 << HasSecondDefaultArgument;
9912 break;
9913 }
9914
9915 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&((HasFirstDefaultArgument && HasSecondDefaultArgument
&& "Expecting default arguments.") ? static_cast<
void> (0) : __assert_fail ("HasFirstDefaultArgument && HasSecondDefaultArgument && \"Expecting default arguments.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9916, __PRETTY_FUNCTION__))
9916 "Expecting default arguments.")((HasFirstDefaultArgument && HasSecondDefaultArgument
&& "Expecting default arguments.") ? static_cast<
void> (0) : __assert_fail ("HasFirstDefaultArgument && HasSecondDefaultArgument && \"Expecting default arguments.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9916, __PRETTY_FUNCTION__))
;
9917
9918 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9919 ParamDifferentDefaultArgument);
9920 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9921 ParamDifferentDefaultArgument);
9922
9923 break;
9924 }
9925 case Decl::NonTypeTemplateParm: {
9926 const auto *FirstParam = cast<NonTypeTemplateParmDecl>(FirstDecl);
9927 const auto *SecondParam = cast<NonTypeTemplateParmDecl>(SecondDecl);
9928 const bool HasFirstDefaultArgument =
9929 FirstParam->hasDefaultArgument() &&
9930 !FirstParam->defaultArgumentWasInherited();
9931 const bool HasSecondDefaultArgument =
9932 SecondParam->hasDefaultArgument() &&
9933 !SecondParam->defaultArgumentWasInherited();
9934
9935 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9936 ODRDiagError(FirstDecl->getLocation(),
9937 FirstDecl->getSourceRange(),
9938 ParamSingleDefaultArgument)
9939 << HasFirstDefaultArgument;
9940 ODRDiagNote(SecondDecl->getLocation(),
9941 SecondDecl->getSourceRange(),
9942 ParamSingleDefaultArgument)
9943 << HasSecondDefaultArgument;
9944 break;
9945 }
9946
9947 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&((HasFirstDefaultArgument && HasSecondDefaultArgument
&& "Expecting default arguments.") ? static_cast<
void> (0) : __assert_fail ("HasFirstDefaultArgument && HasSecondDefaultArgument && \"Expecting default arguments.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9948, __PRETTY_FUNCTION__))
9948 "Expecting default arguments.")((HasFirstDefaultArgument && HasSecondDefaultArgument
&& "Expecting default arguments.") ? static_cast<
void> (0) : __assert_fail ("HasFirstDefaultArgument && HasSecondDefaultArgument && \"Expecting default arguments.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9948, __PRETTY_FUNCTION__))
;
9949
9950 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9951 ParamDifferentDefaultArgument);
9952 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9953 ParamDifferentDefaultArgument);
9954
9955 break;
9956 }
9957 case Decl::TemplateTemplateParm: {
9958 const auto *FirstParam = cast<TemplateTemplateParmDecl>(FirstDecl);
9959 const auto *SecondParam =
9960 cast<TemplateTemplateParmDecl>(SecondDecl);
9961 const bool HasFirstDefaultArgument =
9962 FirstParam->hasDefaultArgument() &&
9963 !FirstParam->defaultArgumentWasInherited();
9964 const bool HasSecondDefaultArgument =
9965 SecondParam->hasDefaultArgument() &&
9966 !SecondParam->defaultArgumentWasInherited();
9967
9968 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
9969 ODRDiagError(FirstDecl->getLocation(),
9970 FirstDecl->getSourceRange(),
9971 ParamSingleDefaultArgument)
9972 << HasFirstDefaultArgument;
9973 ODRDiagNote(SecondDecl->getLocation(),
9974 SecondDecl->getSourceRange(),
9975 ParamSingleDefaultArgument)
9976 << HasSecondDefaultArgument;
9977 break;
9978 }
9979
9980 assert(HasFirstDefaultArgument && HasSecondDefaultArgument &&((HasFirstDefaultArgument && HasSecondDefaultArgument
&& "Expecting default arguments.") ? static_cast<
void> (0) : __assert_fail ("HasFirstDefaultArgument && HasSecondDefaultArgument && \"Expecting default arguments.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9981, __PRETTY_FUNCTION__))
9981 "Expecting default arguments.")((HasFirstDefaultArgument && HasSecondDefaultArgument
&& "Expecting default arguments.") ? static_cast<
void> (0) : __assert_fail ("HasFirstDefaultArgument && HasSecondDefaultArgument && \"Expecting default arguments.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 9981, __PRETTY_FUNCTION__))
;
9982
9983 ODRDiagError(FirstDecl->getLocation(), FirstDecl->getSourceRange(),
9984 ParamDifferentDefaultArgument);
9985 ODRDiagNote(SecondDecl->getLocation(), SecondDecl->getSourceRange(),
9986 ParamDifferentDefaultArgument);
9987
9988 break;
9989 }
9990 }
9991
9992 break;
9993 }
9994
9995 if (FirstIt != FirstEnd) {
9996 Diagnosed = true;
9997 break;
9998 }
9999 }
10000
10001 DeclHashes FirstHashes;
10002 DeclHashes SecondHashes;
10003
10004 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstRecord](
10005 DeclHashes &Hashes, CXXRecordDecl *Record) {
10006 for (auto *D : Record->decls()) {
10007 // Due to decl merging, the first CXXRecordDecl is the parent of
10008 // Decls in both records.
10009 if (!ODRHash::isWhitelistedDecl(D, FirstRecord))
10010 continue;
10011 Hashes.emplace_back(D, ComputeSubDeclODRHash(D));
10012 }
10013 };
10014 PopulateHashes(FirstHashes, FirstRecord);
10015 PopulateHashes(SecondHashes, SecondRecord);
10016
10017 // Used with err_module_odr_violation_mismatch_decl and
10018 // note_module_odr_violation_mismatch_decl
10019 // This list should be the same Decl's as in ODRHash::isWhiteListedDecl
10020 enum {
10021 EndOfClass,
10022 PublicSpecifer,
10023 PrivateSpecifer,
10024 ProtectedSpecifer,
10025 StaticAssert,
10026 Field,
10027 CXXMethod,
10028 TypeAlias,
10029 TypeDef,
10030 Var,
10031 Friend,
10032 FunctionTemplate,
10033 Other
10034 } FirstDiffType = Other,
10035 SecondDiffType = Other;
10036
10037 auto DifferenceSelector = [](Decl *D) {
10038 assert(D && "valid Decl required")((D && "valid Decl required") ? static_cast<void>
(0) : __assert_fail ("D && \"valid Decl required\"",
"/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10038, __PRETTY_FUNCTION__))
;
10039 switch (D->getKind()) {
10040 default:
10041 return Other;
10042 case Decl::AccessSpec:
10043 switch (D->getAccess()) {
10044 case AS_public:
10045 return PublicSpecifer;
10046 case AS_private:
10047 return PrivateSpecifer;
10048 case AS_protected:
10049 return ProtectedSpecifer;
10050 case AS_none:
10051 break;
10052 }
10053 llvm_unreachable("Invalid access specifier")::llvm::llvm_unreachable_internal("Invalid access specifier",
"/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10053)
;
10054 case Decl::StaticAssert:
10055 return StaticAssert;
10056 case Decl::Field:
10057 return Field;
10058 case Decl::CXXMethod:
10059 case Decl::CXXConstructor:
10060 case Decl::CXXDestructor:
10061 return CXXMethod;
10062 case Decl::TypeAlias:
10063 return TypeAlias;
10064 case Decl::Typedef:
10065 return TypeDef;
10066 case Decl::Var:
10067 return Var;
10068 case Decl::Friend:
10069 return Friend;
10070 case Decl::FunctionTemplate:
10071 return FunctionTemplate;
10072 }
10073 };
10074
10075 Decl *FirstDecl = nullptr;
10076 Decl *SecondDecl = nullptr;
10077 auto FirstIt = FirstHashes.begin();
10078 auto SecondIt = SecondHashes.begin();
10079
10080 // If there is a diagnoseable difference, FirstDiffType and
10081 // SecondDiffType will not be Other and FirstDecl and SecondDecl will be
10082 // filled in if not EndOfClass.
10083 while (FirstIt != FirstHashes.end() || SecondIt != SecondHashes.end()) {
10084 if (FirstIt != FirstHashes.end() && SecondIt != SecondHashes.end() &&
10085 FirstIt->second == SecondIt->second) {
10086 ++FirstIt;
10087 ++SecondIt;
10088 continue;
10089 }
10090
10091 FirstDecl = FirstIt == FirstHashes.end() ? nullptr : FirstIt->first;
10092 SecondDecl = SecondIt == SecondHashes.end() ? nullptr : SecondIt->first;
10093
10094 FirstDiffType = FirstDecl ? DifferenceSelector(FirstDecl) : EndOfClass;
10095 SecondDiffType =
10096 SecondDecl ? DifferenceSelector(SecondDecl) : EndOfClass;
10097
10098 break;
10099 }
10100
10101 if (FirstDiffType == Other || SecondDiffType == Other) {
10102 // Reaching this point means an unexpected Decl was encountered
10103 // or no difference was detected. This causes a generic error
10104 // message to be emitted.
10105 Diag(FirstRecord->getLocation(),
10106 diag::err_module_odr_violation_different_definitions)
10107 << FirstRecord << FirstModule.empty() << FirstModule;
10108
10109 if (FirstDecl) {
10110 Diag(FirstDecl->getLocation(), diag::note_first_module_difference)
10111 << FirstRecord << FirstDecl->getSourceRange();
10112 }
10113
10114 Diag(SecondRecord->getLocation(),
10115 diag::note_module_odr_violation_different_definitions)
10116 << SecondModule;
10117
10118 if (SecondDecl) {
10119 Diag(SecondDecl->getLocation(), diag::note_second_module_difference)
10120 << SecondDecl->getSourceRange();
10121 }
10122
10123 Diagnosed = true;
10124 break;
10125 }
10126
10127 if (FirstDiffType != SecondDiffType) {
10128 SourceLocation FirstLoc;
10129 SourceRange FirstRange;
10130 if (FirstDiffType == EndOfClass) {
10131 FirstLoc = FirstRecord->getBraceRange().getEnd();
10132 } else {
10133 FirstLoc = FirstIt->first->getLocation();
10134 FirstRange = FirstIt->first->getSourceRange();
10135 }
10136 Diag(FirstLoc, diag::err_module_odr_violation_mismatch_decl)
10137 << FirstRecord << FirstModule.empty() << FirstModule << FirstRange
10138 << FirstDiffType;
10139
10140 SourceLocation SecondLoc;
10141 SourceRange SecondRange;
10142 if (SecondDiffType == EndOfClass) {
10143 SecondLoc = SecondRecord->getBraceRange().getEnd();
10144 } else {
10145 SecondLoc = SecondDecl->getLocation();
10146 SecondRange = SecondDecl->getSourceRange();
10147 }
10148 Diag(SecondLoc, diag::note_module_odr_violation_mismatch_decl)
10149 << SecondModule << SecondRange << SecondDiffType;
10150 Diagnosed = true;
10151 break;
10152 }
10153
10154 assert(FirstDiffType == SecondDiffType)((FirstDiffType == SecondDiffType) ? static_cast<void> (
0) : __assert_fail ("FirstDiffType == SecondDiffType", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10154, __PRETTY_FUNCTION__))
;
10155
10156 // Used with err_module_odr_violation_mismatch_decl_diff and
10157 // note_module_odr_violation_mismatch_decl_diff
10158 enum ODRDeclDifference {
10159 StaticAssertCondition,
10160 StaticAssertMessage,
10161 StaticAssertOnlyMessage,
10162 FieldName,
10163 FieldTypeName,
10164 FieldSingleBitField,
10165 FieldDifferentWidthBitField,
10166 FieldSingleMutable,
10167 FieldSingleInitializer,
10168 FieldDifferentInitializers,
10169 MethodName,
10170 MethodDeleted,
10171 MethodDefaulted,
10172 MethodVirtual,
10173 MethodStatic,
10174 MethodVolatile,
10175 MethodConst,
10176 MethodInline,
10177 MethodNumberParameters,
10178 MethodParameterType,
10179 MethodParameterName,
10180 MethodParameterSingleDefaultArgument,
10181 MethodParameterDifferentDefaultArgument,
10182 MethodNoTemplateArguments,
10183 MethodDifferentNumberTemplateArguments,
10184 MethodDifferentTemplateArgument,
10185 MethodSingleBody,
10186 MethodDifferentBody,
10187 TypedefName,
10188 TypedefType,
10189 VarName,
10190 VarType,
10191 VarSingleInitializer,
10192 VarDifferentInitializer,
10193 VarConstexpr,
10194 FriendTypeFunction,
10195 FriendType,
10196 FriendFunction,
10197 FunctionTemplateDifferentNumberParameters,
10198 FunctionTemplateParameterDifferentKind,
10199 FunctionTemplateParameterName,
10200 FunctionTemplateParameterSingleDefaultArgument,
10201 FunctionTemplateParameterDifferentDefaultArgument,
10202 FunctionTemplateParameterDifferentType,
10203 FunctionTemplatePackParameter,
10204 };
10205
10206 // These lambdas have the common portions of the ODR diagnostics. This
10207 // has the same return as Diag(), so addition parameters can be passed
10208 // in with operator<<
10209 auto ODRDiagError = [FirstRecord, &FirstModule, this](
10210 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10211 return Diag(Loc, diag::err_module_odr_violation_mismatch_decl_diff)
10212 << FirstRecord << FirstModule.empty() << FirstModule << Range
10213 << DiffType;
10214 };
10215 auto ODRDiagNote = [&SecondModule, this](
10216 SourceLocation Loc, SourceRange Range, ODRDeclDifference DiffType) {
10217 return Diag(Loc, diag::note_module_odr_violation_mismatch_decl_diff)
10218 << SecondModule << Range << DiffType;
10219 };
10220
10221 switch (FirstDiffType) {
10222 case Other:
10223 case EndOfClass:
10224 case PublicSpecifer:
10225 case PrivateSpecifer:
10226 case ProtectedSpecifer:
10227 llvm_unreachable("Invalid diff type")::llvm::llvm_unreachable_internal("Invalid diff type", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10227)
;
10228
10229 case StaticAssert: {
10230 StaticAssertDecl *FirstSA = cast<StaticAssertDecl>(FirstDecl);
10231 StaticAssertDecl *SecondSA = cast<StaticAssertDecl>(SecondDecl);
10232
10233 Expr *FirstExpr = FirstSA->getAssertExpr();
10234 Expr *SecondExpr = SecondSA->getAssertExpr();
10235 unsigned FirstODRHash = ComputeODRHash(FirstExpr);
10236 unsigned SecondODRHash = ComputeODRHash(SecondExpr);
10237 if (FirstODRHash != SecondODRHash) {
10238 ODRDiagError(FirstExpr->getBeginLoc(), FirstExpr->getSourceRange(),
10239 StaticAssertCondition);
10240 ODRDiagNote(SecondExpr->getBeginLoc(), SecondExpr->getSourceRange(),
10241 StaticAssertCondition);
10242 Diagnosed = true;
10243 break;
10244 }
10245
10246 StringLiteral *FirstStr = FirstSA->getMessage();
10247 StringLiteral *SecondStr = SecondSA->getMessage();
10248 assert((FirstStr || SecondStr) && "Both messages cannot be empty")(((FirstStr || SecondStr) && "Both messages cannot be empty"
) ? static_cast<void> (0) : __assert_fail ("(FirstStr || SecondStr) && \"Both messages cannot be empty\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10248, __PRETTY_FUNCTION__))
;
10249 if ((FirstStr && !SecondStr) || (!FirstStr && SecondStr)) {
10250 SourceLocation FirstLoc, SecondLoc;
10251 SourceRange FirstRange, SecondRange;
10252 if (FirstStr) {
10253 FirstLoc = FirstStr->getBeginLoc();
10254 FirstRange = FirstStr->getSourceRange();
10255 } else {
10256 FirstLoc = FirstSA->getBeginLoc();
10257 FirstRange = FirstSA->getSourceRange();
10258 }
10259 if (SecondStr) {
10260 SecondLoc = SecondStr->getBeginLoc();
10261 SecondRange = SecondStr->getSourceRange();
10262 } else {
10263 SecondLoc = SecondSA->getBeginLoc();
10264 SecondRange = SecondSA->getSourceRange();
10265 }
10266 ODRDiagError(FirstLoc, FirstRange, StaticAssertOnlyMessage)
10267 << (FirstStr == nullptr);
10268 ODRDiagNote(SecondLoc, SecondRange, StaticAssertOnlyMessage)
10269 << (SecondStr == nullptr);
10270 Diagnosed = true;
10271 break;
10272 }
10273
10274 if (FirstStr && SecondStr &&
10275 FirstStr->getString() != SecondStr->getString()) {
10276 ODRDiagError(FirstStr->getBeginLoc(), FirstStr->getSourceRange(),
10277 StaticAssertMessage);
10278 ODRDiagNote(SecondStr->getBeginLoc(), SecondStr->getSourceRange(),
10279 StaticAssertMessage);
10280 Diagnosed = true;
10281 break;
10282 }
10283 break;
10284 }
10285 case Field: {
10286 FieldDecl *FirstField = cast<FieldDecl>(FirstDecl);
10287 FieldDecl *SecondField = cast<FieldDecl>(SecondDecl);
10288 IdentifierInfo *FirstII = FirstField->getIdentifier();
10289 IdentifierInfo *SecondII = SecondField->getIdentifier();
10290 if (FirstII->getName() != SecondII->getName()) {
10291 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10292 FieldName)
10293 << FirstII;
10294 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10295 FieldName)
10296 << SecondII;
10297
10298 Diagnosed = true;
10299 break;
10300 }
10301
10302 assert(getContext().hasSameType(FirstField->getType(),((getContext().hasSameType(FirstField->getType(), SecondField
->getType())) ? static_cast<void> (0) : __assert_fail
("getContext().hasSameType(FirstField->getType(), SecondField->getType())"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10303, __PRETTY_FUNCTION__))
10303 SecondField->getType()))((getContext().hasSameType(FirstField->getType(), SecondField
->getType())) ? static_cast<void> (0) : __assert_fail
("getContext().hasSameType(FirstField->getType(), SecondField->getType())"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10303, __PRETTY_FUNCTION__))
;
10304
10305 QualType FirstType = FirstField->getType();
10306 QualType SecondType = SecondField->getType();
10307 if (ComputeQualTypeODRHash(FirstType) !=
10308 ComputeQualTypeODRHash(SecondType)) {
10309 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10310 FieldTypeName)
10311 << FirstII << FirstType;
10312 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10313 FieldTypeName)
10314 << SecondII << SecondType;
10315
10316 Diagnosed = true;
10317 break;
10318 }
10319
10320 const bool IsFirstBitField = FirstField->isBitField();
10321 const bool IsSecondBitField = SecondField->isBitField();
10322 if (IsFirstBitField != IsSecondBitField) {
10323 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10324 FieldSingleBitField)
10325 << FirstII << IsFirstBitField;
10326 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10327 FieldSingleBitField)
10328 << SecondII << IsSecondBitField;
10329 Diagnosed = true;
10330 break;
10331 }
10332
10333 if (IsFirstBitField && IsSecondBitField) {
10334 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10335 FieldDifferentWidthBitField)
10336 << FirstII << FirstField->getBitWidth()->getSourceRange();
10337 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10338 FieldDifferentWidthBitField)
10339 << SecondII << SecondField->getBitWidth()->getSourceRange();
10340 Diagnosed = true;
10341 break;
10342 }
10343
10344 const bool IsFirstMutable = FirstField->isMutable();
10345 const bool IsSecondMutable = SecondField->isMutable();
10346 if (IsFirstMutable != IsSecondMutable) {
10347 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10348 FieldSingleMutable)
10349 << FirstII << IsFirstMutable;
10350 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10351 FieldSingleMutable)
10352 << SecondII << IsSecondMutable;
10353 Diagnosed = true;
10354 break;
10355 }
10356
10357 const Expr *FirstInitializer = FirstField->getInClassInitializer();
10358 const Expr *SecondInitializer = SecondField->getInClassInitializer();
10359 if ((!FirstInitializer && SecondInitializer) ||
10360 (FirstInitializer && !SecondInitializer)) {
10361 ODRDiagError(FirstField->getLocation(), FirstField->getSourceRange(),
10362 FieldSingleInitializer)
10363 << FirstII << (FirstInitializer != nullptr);
10364 ODRDiagNote(SecondField->getLocation(), SecondField->getSourceRange(),
10365 FieldSingleInitializer)
10366 << SecondII << (SecondInitializer != nullptr);
10367 Diagnosed = true;
10368 break;
10369 }
10370
10371 if (FirstInitializer && SecondInitializer) {
10372 unsigned FirstInitHash = ComputeODRHash(FirstInitializer);
10373 unsigned SecondInitHash = ComputeODRHash(SecondInitializer);
10374 if (FirstInitHash != SecondInitHash) {
10375 ODRDiagError(FirstField->getLocation(),
10376 FirstField->getSourceRange(),
10377 FieldDifferentInitializers)
10378 << FirstII << FirstInitializer->getSourceRange();
10379 ODRDiagNote(SecondField->getLocation(),
10380 SecondField->getSourceRange(),
10381 FieldDifferentInitializers)
10382 << SecondII << SecondInitializer->getSourceRange();
10383 Diagnosed = true;
10384 break;
10385 }
10386 }
10387
10388 break;
10389 }
10390 case CXXMethod: {
10391 enum {
10392 DiagMethod,
10393 DiagConstructor,
10394 DiagDestructor,
10395 } FirstMethodType,
10396 SecondMethodType;
10397 auto GetMethodTypeForDiagnostics = [](const CXXMethodDecl* D) {
10398 if (isa<CXXConstructorDecl>(D)) return DiagConstructor;
10399 if (isa<CXXDestructorDecl>(D)) return DiagDestructor;
10400 return DiagMethod;
10401 };
10402 const CXXMethodDecl *FirstMethod = cast<CXXMethodDecl>(FirstDecl);
10403 const CXXMethodDecl *SecondMethod = cast<CXXMethodDecl>(SecondDecl);
10404 FirstMethodType = GetMethodTypeForDiagnostics(FirstMethod);
10405 SecondMethodType = GetMethodTypeForDiagnostics(SecondMethod);
10406 auto FirstName = FirstMethod->getDeclName();
10407 auto SecondName = SecondMethod->getDeclName();
10408 if (FirstMethodType != SecondMethodType || FirstName != SecondName) {
10409 ODRDiagError(FirstMethod->getLocation(),
10410 FirstMethod->getSourceRange(), MethodName)
10411 << FirstMethodType << FirstName;
10412 ODRDiagNote(SecondMethod->getLocation(),
10413 SecondMethod->getSourceRange(), MethodName)
10414 << SecondMethodType << SecondName;
10415
10416 Diagnosed = true;
10417 break;
10418 }
10419
10420 const bool FirstDeleted = FirstMethod->isDeletedAsWritten();
10421 const bool SecondDeleted = SecondMethod->isDeletedAsWritten();
10422 if (FirstDeleted != SecondDeleted) {
10423 ODRDiagError(FirstMethod->getLocation(),
10424 FirstMethod->getSourceRange(), MethodDeleted)
10425 << FirstMethodType << FirstName << FirstDeleted;
10426
10427 ODRDiagNote(SecondMethod->getLocation(),
10428 SecondMethod->getSourceRange(), MethodDeleted)
10429 << SecondMethodType << SecondName << SecondDeleted;
10430 Diagnosed = true;
10431 break;
10432 }
10433
10434 const bool FirstDefaulted = FirstMethod->isExplicitlyDefaulted();
10435 const bool SecondDefaulted = SecondMethod->isExplicitlyDefaulted();
10436 if (FirstDefaulted != SecondDefaulted) {
10437 ODRDiagError(FirstMethod->getLocation(),
10438 FirstMethod->getSourceRange(), MethodDefaulted)
10439 << FirstMethodType << FirstName << FirstDefaulted;
10440
10441 ODRDiagNote(SecondMethod->getLocation(),
10442 SecondMethod->getSourceRange(), MethodDefaulted)
10443 << SecondMethodType << SecondName << SecondDefaulted;
10444 Diagnosed = true;
10445 break;
10446 }
10447
10448 const bool FirstVirtual = FirstMethod->isVirtualAsWritten();
10449 const bool SecondVirtual = SecondMethod->isVirtualAsWritten();
10450 const bool FirstPure = FirstMethod->isPure();
10451 const bool SecondPure = SecondMethod->isPure();
10452 if ((FirstVirtual || SecondVirtual) &&
10453 (FirstVirtual != SecondVirtual || FirstPure != SecondPure)) {
10454 ODRDiagError(FirstMethod->getLocation(),
10455 FirstMethod->getSourceRange(), MethodVirtual)
10456 << FirstMethodType << FirstName << FirstPure << FirstVirtual;
10457 ODRDiagNote(SecondMethod->getLocation(),
10458 SecondMethod->getSourceRange(), MethodVirtual)
10459 << SecondMethodType << SecondName << SecondPure << SecondVirtual;
10460 Diagnosed = true;
10461 break;
10462 }
10463
10464 // CXXMethodDecl::isStatic uses the canonical Decl. With Decl merging,
10465 // FirstDecl is the canonical Decl of SecondDecl, so the storage
10466 // class needs to be checked instead.
10467 const auto FirstStorage = FirstMethod->getStorageClass();
10468 const auto SecondStorage = SecondMethod->getStorageClass();
10469 const bool FirstStatic = FirstStorage == SC_Static;
10470 const bool SecondStatic = SecondStorage == SC_Static;
10471 if (FirstStatic != SecondStatic) {
10472 ODRDiagError(FirstMethod->getLocation(),
10473 FirstMethod->getSourceRange(), MethodStatic)
10474 << FirstMethodType << FirstName << FirstStatic;
10475 ODRDiagNote(SecondMethod->getLocation(),
10476 SecondMethod->getSourceRange(), MethodStatic)
10477 << SecondMethodType << SecondName << SecondStatic;
10478 Diagnosed = true;
10479 break;
10480 }
10481
10482 const bool FirstVolatile = FirstMethod->isVolatile();
10483 const bool SecondVolatile = SecondMethod->isVolatile();
10484 if (FirstVolatile != SecondVolatile) {
10485 ODRDiagError(FirstMethod->getLocation(),
10486 FirstMethod->getSourceRange(), MethodVolatile)
10487 << FirstMethodType << FirstName << FirstVolatile;
10488 ODRDiagNote(SecondMethod->getLocation(),
10489 SecondMethod->getSourceRange(), MethodVolatile)
10490 << SecondMethodType << SecondName << SecondVolatile;
10491 Diagnosed = true;
10492 break;
10493 }
10494
10495 const bool FirstConst = FirstMethod->isConst();
10496 const bool SecondConst = SecondMethod->isConst();
10497 if (FirstConst != SecondConst) {
10498 ODRDiagError(FirstMethod->getLocation(),
10499 FirstMethod->getSourceRange(), MethodConst)
10500 << FirstMethodType << FirstName << FirstConst;
10501 ODRDiagNote(SecondMethod->getLocation(),
10502 SecondMethod->getSourceRange(), MethodConst)
10503 << SecondMethodType << SecondName << SecondConst;
10504 Diagnosed = true;
10505 break;
10506 }
10507
10508 const bool FirstInline = FirstMethod->isInlineSpecified();
10509 const bool SecondInline = SecondMethod->isInlineSpecified();
10510 if (FirstInline != SecondInline) {
10511 ODRDiagError(FirstMethod->getLocation(),
10512 FirstMethod->getSourceRange(), MethodInline)
10513 << FirstMethodType << FirstName << FirstInline;
10514 ODRDiagNote(SecondMethod->getLocation(),
10515 SecondMethod->getSourceRange(), MethodInline)
10516 << SecondMethodType << SecondName << SecondInline;
10517 Diagnosed = true;
10518 break;
10519 }
10520
10521 const unsigned FirstNumParameters = FirstMethod->param_size();
10522 const unsigned SecondNumParameters = SecondMethod->param_size();
10523 if (FirstNumParameters != SecondNumParameters) {
10524 ODRDiagError(FirstMethod->getLocation(),
10525 FirstMethod->getSourceRange(), MethodNumberParameters)
10526 << FirstMethodType << FirstName << FirstNumParameters;
10527 ODRDiagNote(SecondMethod->getLocation(),
10528 SecondMethod->getSourceRange(), MethodNumberParameters)
10529 << SecondMethodType << SecondName << SecondNumParameters;
10530 Diagnosed = true;
10531 break;
10532 }
10533
10534 // Need this status boolean to know when break out of the switch.
10535 bool ParameterMismatch = false;
10536 for (unsigned I = 0; I < FirstNumParameters; ++I) {
10537 const ParmVarDecl *FirstParam = FirstMethod->getParamDecl(I);
10538 const ParmVarDecl *SecondParam = SecondMethod->getParamDecl(I);
10539
10540 QualType FirstParamType = FirstParam->getType();
10541 QualType SecondParamType = SecondParam->getType();
10542 if (FirstParamType != SecondParamType &&
10543 ComputeQualTypeODRHash(FirstParamType) !=
10544 ComputeQualTypeODRHash(SecondParamType)) {
10545 if (const DecayedType *ParamDecayedType =
10546 FirstParamType->getAs<DecayedType>()) {
10547 ODRDiagError(FirstMethod->getLocation(),
10548 FirstMethod->getSourceRange(), MethodParameterType)
10549 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10550 << true << ParamDecayedType->getOriginalType();
10551 } else {
10552 ODRDiagError(FirstMethod->getLocation(),
10553 FirstMethod->getSourceRange(), MethodParameterType)
10554 << FirstMethodType << FirstName << (I + 1) << FirstParamType
10555 << false;
10556 }
10557
10558 if (const DecayedType *ParamDecayedType =
10559 SecondParamType->getAs<DecayedType>()) {
10560 ODRDiagNote(SecondMethod->getLocation(),
10561 SecondMethod->getSourceRange(), MethodParameterType)
10562 << SecondMethodType << SecondName << (I + 1)
10563 << SecondParamType << true
10564 << ParamDecayedType->getOriginalType();
10565 } else {
10566 ODRDiagNote(SecondMethod->getLocation(),
10567 SecondMethod->getSourceRange(), MethodParameterType)
10568 << SecondMethodType << SecondName << (I + 1)
10569 << SecondParamType << false;
10570 }
10571 ParameterMismatch = true;
10572 break;
10573 }
10574
10575 DeclarationName FirstParamName = FirstParam->getDeclName();
10576 DeclarationName SecondParamName = SecondParam->getDeclName();
10577 if (FirstParamName != SecondParamName) {
10578 ODRDiagError(FirstMethod->getLocation(),
10579 FirstMethod->getSourceRange(), MethodParameterName)
10580 << FirstMethodType << FirstName << (I + 1) << FirstParamName;
10581 ODRDiagNote(SecondMethod->getLocation(),
10582 SecondMethod->getSourceRange(), MethodParameterName)
10583 << SecondMethodType << SecondName << (I + 1) << SecondParamName;
10584 ParameterMismatch = true;
10585 break;
10586 }
10587
10588 const Expr *FirstInit = FirstParam->getInit();
10589 const Expr *SecondInit = SecondParam->getInit();
10590 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10591 ODRDiagError(FirstMethod->getLocation(),
10592 FirstMethod->getSourceRange(),
10593 MethodParameterSingleDefaultArgument)
10594 << FirstMethodType << FirstName << (I + 1)
10595 << (FirstInit == nullptr)
10596 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
10597 ODRDiagNote(SecondMethod->getLocation(),
10598 SecondMethod->getSourceRange(),
10599 MethodParameterSingleDefaultArgument)
10600 << SecondMethodType << SecondName << (I + 1)
10601 << (SecondInit == nullptr)
10602 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10603 ParameterMismatch = true;
10604 break;
10605 }
10606
10607 if (FirstInit && SecondInit &&
10608 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10609 ODRDiagError(FirstMethod->getLocation(),
10610 FirstMethod->getSourceRange(),
10611 MethodParameterDifferentDefaultArgument)
10612 << FirstMethodType << FirstName << (I + 1)
10613 << FirstInit->getSourceRange();
10614 ODRDiagNote(SecondMethod->getLocation(),
10615 SecondMethod->getSourceRange(),
10616 MethodParameterDifferentDefaultArgument)
10617 << SecondMethodType << SecondName << (I + 1)
10618 << SecondInit->getSourceRange();
10619 ParameterMismatch = true;
10620 break;
10621
10622 }
10623 }
10624
10625 if (ParameterMismatch) {
10626 Diagnosed = true;
10627 break;
10628 }
10629
10630 const auto *FirstTemplateArgs =
10631 FirstMethod->getTemplateSpecializationArgs();
10632 const auto *SecondTemplateArgs =
10633 SecondMethod->getTemplateSpecializationArgs();
10634
10635 if ((FirstTemplateArgs && !SecondTemplateArgs) ||
10636 (!FirstTemplateArgs && SecondTemplateArgs)) {
10637 ODRDiagError(FirstMethod->getLocation(),
10638 FirstMethod->getSourceRange(), MethodNoTemplateArguments)
10639 << FirstMethodType << FirstName << (FirstTemplateArgs != nullptr);
10640 ODRDiagNote(SecondMethod->getLocation(),
10641 SecondMethod->getSourceRange(), MethodNoTemplateArguments)
10642 << SecondMethodType << SecondName
10643 << (SecondTemplateArgs != nullptr);
10644
10645 Diagnosed = true;
10646 break;
10647 }
10648
10649 if (FirstTemplateArgs && SecondTemplateArgs) {
10650 // Remove pack expansions from argument list.
10651 auto ExpandTemplateArgumentList =
10652 [](const TemplateArgumentList *TAL) {
10653 llvm::SmallVector<const TemplateArgument *, 8> ExpandedList;
10654 for (const TemplateArgument &TA : TAL->asArray()) {
10655 if (TA.getKind() != TemplateArgument::Pack) {
10656 ExpandedList.push_back(&TA);
10657 continue;
10658 }
10659 for (const TemplateArgument &PackTA : TA.getPackAsArray()) {
10660 ExpandedList.push_back(&PackTA);
10661 }
10662 }
10663 return ExpandedList;
10664 };
10665 llvm::SmallVector<const TemplateArgument *, 8> FirstExpandedList =
10666 ExpandTemplateArgumentList(FirstTemplateArgs);
10667 llvm::SmallVector<const TemplateArgument *, 8> SecondExpandedList =
10668 ExpandTemplateArgumentList(SecondTemplateArgs);
10669
10670 if (FirstExpandedList.size() != SecondExpandedList.size()) {
10671 ODRDiagError(FirstMethod->getLocation(),
10672 FirstMethod->getSourceRange(),
10673 MethodDifferentNumberTemplateArguments)
10674 << FirstMethodType << FirstName
10675 << (unsigned)FirstExpandedList.size();
10676 ODRDiagNote(SecondMethod->getLocation(),
10677 SecondMethod->getSourceRange(),
10678 MethodDifferentNumberTemplateArguments)
10679 << SecondMethodType << SecondName
10680 << (unsigned)SecondExpandedList.size();
10681
10682 Diagnosed = true;
10683 break;
10684 }
10685
10686 bool TemplateArgumentMismatch = false;
10687 for (unsigned i = 0, e = FirstExpandedList.size(); i != e; ++i) {
10688 const TemplateArgument &FirstTA = *FirstExpandedList[i],
10689 &SecondTA = *SecondExpandedList[i];
10690 if (ComputeTemplateArgumentODRHash(FirstTA) ==
10691 ComputeTemplateArgumentODRHash(SecondTA)) {
10692 continue;
10693 }
10694
10695 ODRDiagError(FirstMethod->getLocation(),
10696 FirstMethod->getSourceRange(),
10697 MethodDifferentTemplateArgument)
10698 << FirstMethodType << FirstName << FirstTA << i + 1;
10699 ODRDiagNote(SecondMethod->getLocation(),
10700 SecondMethod->getSourceRange(),
10701 MethodDifferentTemplateArgument)
10702 << SecondMethodType << SecondName << SecondTA << i + 1;
10703
10704 TemplateArgumentMismatch = true;
10705 break;
10706 }
10707
10708 if (TemplateArgumentMismatch) {
10709 Diagnosed = true;
10710 break;
10711 }
10712 }
10713
10714 // Compute the hash of the method as if it has no body.
10715 auto ComputeCXXMethodODRHash = [&Hash](const CXXMethodDecl *D) {
10716 Hash.clear();
10717 Hash.AddFunctionDecl(D, true /*SkipBody*/);
10718 return Hash.CalculateHash();
10719 };
10720
10721 // Compare the hash generated to the hash stored. A difference means
10722 // that a body was present in the original source. Due to merging,
10723 // the stardard way of detecting a body will not work.
10724 const bool HasFirstBody =
10725 ComputeCXXMethodODRHash(FirstMethod) != FirstMethod->getODRHash();
10726 const bool HasSecondBody =
10727 ComputeCXXMethodODRHash(SecondMethod) != SecondMethod->getODRHash();
10728
10729 if (HasFirstBody != HasSecondBody) {
10730 ODRDiagError(FirstMethod->getLocation(),
10731 FirstMethod->getSourceRange(), MethodSingleBody)
10732 << FirstMethodType << FirstName << HasFirstBody;
10733 ODRDiagNote(SecondMethod->getLocation(),
10734 SecondMethod->getSourceRange(), MethodSingleBody)
10735 << SecondMethodType << SecondName << HasSecondBody;
10736 Diagnosed = true;
10737 break;
10738 }
10739
10740 if (HasFirstBody && HasSecondBody) {
10741 ODRDiagError(FirstMethod->getLocation(),
10742 FirstMethod->getSourceRange(), MethodDifferentBody)
10743 << FirstMethodType << FirstName;
10744 ODRDiagNote(SecondMethod->getLocation(),
10745 SecondMethod->getSourceRange(), MethodDifferentBody)
10746 << SecondMethodType << SecondName;
10747 Diagnosed = true;
10748 break;
10749 }
10750
10751 break;
10752 }
10753 case TypeAlias:
10754 case TypeDef: {
10755 TypedefNameDecl *FirstTD = cast<TypedefNameDecl>(FirstDecl);
10756 TypedefNameDecl *SecondTD = cast<TypedefNameDecl>(SecondDecl);
10757 auto FirstName = FirstTD->getDeclName();
10758 auto SecondName = SecondTD->getDeclName();
10759 if (FirstName != SecondName) {
10760 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10761 TypedefName)
10762 << (FirstDiffType == TypeAlias) << FirstName;
10763 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10764 TypedefName)
10765 << (FirstDiffType == TypeAlias) << SecondName;
10766 Diagnosed = true;
10767 break;
10768 }
10769
10770 QualType FirstType = FirstTD->getUnderlyingType();
10771 QualType SecondType = SecondTD->getUnderlyingType();
10772 if (ComputeQualTypeODRHash(FirstType) !=
10773 ComputeQualTypeODRHash(SecondType)) {
10774 ODRDiagError(FirstTD->getLocation(), FirstTD->getSourceRange(),
10775 TypedefType)
10776 << (FirstDiffType == TypeAlias) << FirstName << FirstType;
10777 ODRDiagNote(SecondTD->getLocation(), SecondTD->getSourceRange(),
10778 TypedefType)
10779 << (FirstDiffType == TypeAlias) << SecondName << SecondType;
10780 Diagnosed = true;
10781 break;
10782 }
10783 break;
10784 }
10785 case Var: {
10786 VarDecl *FirstVD = cast<VarDecl>(FirstDecl);
10787 VarDecl *SecondVD = cast<VarDecl>(SecondDecl);
10788 auto FirstName = FirstVD->getDeclName();
10789 auto SecondName = SecondVD->getDeclName();
10790 if (FirstName != SecondName) {
10791 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10792 VarName)
10793 << FirstName;
10794 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10795 VarName)
10796 << SecondName;
10797 Diagnosed = true;
10798 break;
10799 }
10800
10801 QualType FirstType = FirstVD->getType();
10802 QualType SecondType = SecondVD->getType();
10803 if (ComputeQualTypeODRHash(FirstType) !=
10804 ComputeQualTypeODRHash(SecondType)) {
10805 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10806 VarType)
10807 << FirstName << FirstType;
10808 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10809 VarType)
10810 << SecondName << SecondType;
10811 Diagnosed = true;
10812 break;
10813 }
10814
10815 const Expr *FirstInit = FirstVD->getInit();
10816 const Expr *SecondInit = SecondVD->getInit();
10817 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
10818 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10819 VarSingleInitializer)
10820 << FirstName << (FirstInit == nullptr)
10821 << (FirstInit ? FirstInit->getSourceRange(): SourceRange());
10822 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10823 VarSingleInitializer)
10824 << SecondName << (SecondInit == nullptr)
10825 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
10826 Diagnosed = true;
10827 break;
10828 }
10829
10830 if (FirstInit && SecondInit &&
10831 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
10832 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10833 VarDifferentInitializer)
10834 << FirstName << FirstInit->getSourceRange();
10835 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10836 VarDifferentInitializer)
10837 << SecondName << SecondInit->getSourceRange();
10838 Diagnosed = true;
10839 break;
10840 }
10841
10842 const bool FirstIsConstexpr = FirstVD->isConstexpr();
10843 const bool SecondIsConstexpr = SecondVD->isConstexpr();
10844 if (FirstIsConstexpr != SecondIsConstexpr) {
10845 ODRDiagError(FirstVD->getLocation(), FirstVD->getSourceRange(),
10846 VarConstexpr)
10847 << FirstName << FirstIsConstexpr;
10848 ODRDiagNote(SecondVD->getLocation(), SecondVD->getSourceRange(),
10849 VarConstexpr)
10850 << SecondName << SecondIsConstexpr;
10851 Diagnosed = true;
10852 break;
10853 }
10854 break;
10855 }
10856 case Friend: {
10857 FriendDecl *FirstFriend = cast<FriendDecl>(FirstDecl);
10858 FriendDecl *SecondFriend = cast<FriendDecl>(SecondDecl);
10859
10860 NamedDecl *FirstND = FirstFriend->getFriendDecl();
10861 NamedDecl *SecondND = SecondFriend->getFriendDecl();
10862
10863 TypeSourceInfo *FirstTSI = FirstFriend->getFriendType();
10864 TypeSourceInfo *SecondTSI = SecondFriend->getFriendType();
10865
10866 if (FirstND && SecondND) {
10867 ODRDiagError(FirstFriend->getFriendLoc(),
10868 FirstFriend->getSourceRange(), FriendFunction)
10869 << FirstND;
10870 ODRDiagNote(SecondFriend->getFriendLoc(),
10871 SecondFriend->getSourceRange(), FriendFunction)
10872 << SecondND;
10873
10874 Diagnosed = true;
10875 break;
10876 }
10877
10878 if (FirstTSI && SecondTSI) {
10879 QualType FirstFriendType = FirstTSI->getType();
10880 QualType SecondFriendType = SecondTSI->getType();
10881 assert(ComputeQualTypeODRHash(FirstFriendType) !=((ComputeQualTypeODRHash(FirstFriendType) != ComputeQualTypeODRHash
(SecondFriendType)) ? static_cast<void> (0) : __assert_fail
("ComputeQualTypeODRHash(FirstFriendType) != ComputeQualTypeODRHash(SecondFriendType)"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10882, __PRETTY_FUNCTION__))
10882 ComputeQualTypeODRHash(SecondFriendType))((ComputeQualTypeODRHash(FirstFriendType) != ComputeQualTypeODRHash
(SecondFriendType)) ? static_cast<void> (0) : __assert_fail
("ComputeQualTypeODRHash(FirstFriendType) != ComputeQualTypeODRHash(SecondFriendType)"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10882, __PRETTY_FUNCTION__))
;
10883 ODRDiagError(FirstFriend->getFriendLoc(),
10884 FirstFriend->getSourceRange(), FriendType)
10885 << FirstFriendType;
10886 ODRDiagNote(SecondFriend->getFriendLoc(),
10887 SecondFriend->getSourceRange(), FriendType)
10888 << SecondFriendType;
10889 Diagnosed = true;
10890 break;
10891 }
10892
10893 ODRDiagError(FirstFriend->getFriendLoc(), FirstFriend->getSourceRange(),
10894 FriendTypeFunction)
10895 << (FirstTSI == nullptr);
10896 ODRDiagNote(SecondFriend->getFriendLoc(),
10897 SecondFriend->getSourceRange(), FriendTypeFunction)
10898 << (SecondTSI == nullptr);
10899
10900 Diagnosed = true;
10901 break;
10902 }
10903 case FunctionTemplate: {
10904 FunctionTemplateDecl *FirstTemplate =
10905 cast<FunctionTemplateDecl>(FirstDecl);
10906 FunctionTemplateDecl *SecondTemplate =
10907 cast<FunctionTemplateDecl>(SecondDecl);
10908
10909 TemplateParameterList *FirstTPL =
10910 FirstTemplate->getTemplateParameters();
10911 TemplateParameterList *SecondTPL =
10912 SecondTemplate->getTemplateParameters();
10913
10914 if (FirstTPL->size() != SecondTPL->size()) {
10915 ODRDiagError(FirstTemplate->getLocation(),
10916 FirstTemplate->getSourceRange(),
10917 FunctionTemplateDifferentNumberParameters)
10918 << FirstTemplate << FirstTPL->size();
10919 ODRDiagNote(SecondTemplate->getLocation(),
10920 SecondTemplate->getSourceRange(),
10921 FunctionTemplateDifferentNumberParameters)
10922 << SecondTemplate << SecondTPL->size();
10923
10924 Diagnosed = true;
10925 break;
10926 }
10927
10928 bool ParameterMismatch = false;
10929 for (unsigned i = 0, e = FirstTPL->size(); i != e; ++i) {
10930 NamedDecl *FirstParam = FirstTPL->getParam(i);
10931 NamedDecl *SecondParam = SecondTPL->getParam(i);
10932
10933 if (FirstParam->getKind() != SecondParam->getKind()) {
10934 enum {
10935 TemplateTypeParameter,
10936 NonTypeTemplateParameter,
10937 TemplateTemplateParameter,
10938 };
10939 auto GetParamType = [](NamedDecl *D) {
10940 switch (D->getKind()) {
10941 default:
10942 llvm_unreachable("Unexpected template parameter type")::llvm::llvm_unreachable_internal("Unexpected template parameter type"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 10942)
;
10943 case Decl::TemplateTypeParm:
10944 return TemplateTypeParameter;
10945 case Decl::NonTypeTemplateParm:
10946 return NonTypeTemplateParameter;
10947 case Decl::TemplateTemplateParm:
10948 return TemplateTemplateParameter;
10949 }
10950 };
10951
10952 ODRDiagError(FirstTemplate->getLocation(),
10953 FirstTemplate->getSourceRange(),
10954 FunctionTemplateParameterDifferentKind)
10955 << FirstTemplate << (i + 1) << GetParamType(FirstParam);
10956 ODRDiagNote(SecondTemplate->getLocation(),
10957 SecondTemplate->getSourceRange(),
10958 FunctionTemplateParameterDifferentKind)
10959 << SecondTemplate << (i + 1) << GetParamType(SecondParam);
10960
10961 ParameterMismatch = true;
10962 break;
10963 }
10964
10965 if (FirstParam->getName() != SecondParam->getName()) {
10966 ODRDiagError(FirstTemplate->getLocation(),
10967 FirstTemplate->getSourceRange(),
10968 FunctionTemplateParameterName)
10969 << FirstTemplate << (i + 1) << (bool)FirstParam->getIdentifier()
10970 << FirstParam;
10971 ODRDiagNote(SecondTemplate->getLocation(),
10972 SecondTemplate->getSourceRange(),
10973 FunctionTemplateParameterName)
10974 << SecondTemplate << (i + 1)
10975 << (bool)SecondParam->getIdentifier() << SecondParam;
10976 ParameterMismatch = true;
10977 break;
10978 }
10979
10980 if (isa<TemplateTypeParmDecl>(FirstParam) &&
10981 isa<TemplateTypeParmDecl>(SecondParam)) {
10982 TemplateTypeParmDecl *FirstTTPD =
10983 cast<TemplateTypeParmDecl>(FirstParam);
10984 TemplateTypeParmDecl *SecondTTPD =
10985 cast<TemplateTypeParmDecl>(SecondParam);
10986 bool HasFirstDefaultArgument =
10987 FirstTTPD->hasDefaultArgument() &&
10988 !FirstTTPD->defaultArgumentWasInherited();
10989 bool HasSecondDefaultArgument =
10990 SecondTTPD->hasDefaultArgument() &&
10991 !SecondTTPD->defaultArgumentWasInherited();
10992 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
10993 ODRDiagError(FirstTemplate->getLocation(),
10994 FirstTemplate->getSourceRange(),
10995 FunctionTemplateParameterSingleDefaultArgument)
10996 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
10997 ODRDiagNote(SecondTemplate->getLocation(),
10998 SecondTemplate->getSourceRange(),
10999 FunctionTemplateParameterSingleDefaultArgument)
11000 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11001 ParameterMismatch = true;
11002 break;
11003 }
11004
11005 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11006 QualType FirstType = FirstTTPD->getDefaultArgument();
11007 QualType SecondType = SecondTTPD->getDefaultArgument();
11008 if (ComputeQualTypeODRHash(FirstType) !=
11009 ComputeQualTypeODRHash(SecondType)) {
11010 ODRDiagError(FirstTemplate->getLocation(),
11011 FirstTemplate->getSourceRange(),
11012 FunctionTemplateParameterDifferentDefaultArgument)
11013 << FirstTemplate << (i + 1) << FirstType;
11014 ODRDiagNote(SecondTemplate->getLocation(),
11015 SecondTemplate->getSourceRange(),
11016 FunctionTemplateParameterDifferentDefaultArgument)
11017 << SecondTemplate << (i + 1) << SecondType;
11018 ParameterMismatch = true;
11019 break;
11020 }
11021 }
11022
11023 if (FirstTTPD->isParameterPack() !=
11024 SecondTTPD->isParameterPack()) {
11025 ODRDiagError(FirstTemplate->getLocation(),
11026 FirstTemplate->getSourceRange(),
11027 FunctionTemplatePackParameter)
11028 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11029 ODRDiagNote(SecondTemplate->getLocation(),
11030 SecondTemplate->getSourceRange(),
11031 FunctionTemplatePackParameter)
11032 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11033 ParameterMismatch = true;
11034 break;
11035 }
11036 }
11037
11038 if (isa<TemplateTemplateParmDecl>(FirstParam) &&
11039 isa<TemplateTemplateParmDecl>(SecondParam)) {
11040 TemplateTemplateParmDecl *FirstTTPD =
11041 cast<TemplateTemplateParmDecl>(FirstParam);
11042 TemplateTemplateParmDecl *SecondTTPD =
11043 cast<TemplateTemplateParmDecl>(SecondParam);
11044
11045 TemplateParameterList *FirstTPL =
11046 FirstTTPD->getTemplateParameters();
11047 TemplateParameterList *SecondTPL =
11048 SecondTTPD->getTemplateParameters();
11049
11050 if (ComputeTemplateParameterListODRHash(FirstTPL) !=
11051 ComputeTemplateParameterListODRHash(SecondTPL)) {
11052 ODRDiagError(FirstTemplate->getLocation(),
11053 FirstTemplate->getSourceRange(),
11054 FunctionTemplateParameterDifferentType)
11055 << FirstTemplate << (i + 1);
11056 ODRDiagNote(SecondTemplate->getLocation(),
11057 SecondTemplate->getSourceRange(),
11058 FunctionTemplateParameterDifferentType)
11059 << SecondTemplate << (i + 1);
11060 ParameterMismatch = true;
11061 break;
11062 }
11063
11064 bool HasFirstDefaultArgument =
11065 FirstTTPD->hasDefaultArgument() &&
11066 !FirstTTPD->defaultArgumentWasInherited();
11067 bool HasSecondDefaultArgument =
11068 SecondTTPD->hasDefaultArgument() &&
11069 !SecondTTPD->defaultArgumentWasInherited();
11070 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11071 ODRDiagError(FirstTemplate->getLocation(),
11072 FirstTemplate->getSourceRange(),
11073 FunctionTemplateParameterSingleDefaultArgument)
11074 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11075 ODRDiagNote(SecondTemplate->getLocation(),
11076 SecondTemplate->getSourceRange(),
11077 FunctionTemplateParameterSingleDefaultArgument)
11078 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11079 ParameterMismatch = true;
11080 break;
11081 }
11082
11083 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11084 TemplateArgument FirstTA =
11085 FirstTTPD->getDefaultArgument().getArgument();
11086 TemplateArgument SecondTA =
11087 SecondTTPD->getDefaultArgument().getArgument();
11088 if (ComputeTemplateArgumentODRHash(FirstTA) !=
11089 ComputeTemplateArgumentODRHash(SecondTA)) {
11090 ODRDiagError(FirstTemplate->getLocation(),
11091 FirstTemplate->getSourceRange(),
11092 FunctionTemplateParameterDifferentDefaultArgument)
11093 << FirstTemplate << (i + 1) << FirstTA;
11094 ODRDiagNote(SecondTemplate->getLocation(),
11095 SecondTemplate->getSourceRange(),
11096 FunctionTemplateParameterDifferentDefaultArgument)
11097 << SecondTemplate << (i + 1) << SecondTA;
11098 ParameterMismatch = true;
11099 break;
11100 }
11101 }
11102
11103 if (FirstTTPD->isParameterPack() !=
11104 SecondTTPD->isParameterPack()) {
11105 ODRDiagError(FirstTemplate->getLocation(),
11106 FirstTemplate->getSourceRange(),
11107 FunctionTemplatePackParameter)
11108 << FirstTemplate << (i + 1) << FirstTTPD->isParameterPack();
11109 ODRDiagNote(SecondTemplate->getLocation(),
11110 SecondTemplate->getSourceRange(),
11111 FunctionTemplatePackParameter)
11112 << SecondTemplate << (i + 1) << SecondTTPD->isParameterPack();
11113 ParameterMismatch = true;
11114 break;
11115 }
11116 }
11117
11118 if (isa<NonTypeTemplateParmDecl>(FirstParam) &&
11119 isa<NonTypeTemplateParmDecl>(SecondParam)) {
11120 NonTypeTemplateParmDecl *FirstNTTPD =
11121 cast<NonTypeTemplateParmDecl>(FirstParam);
11122 NonTypeTemplateParmDecl *SecondNTTPD =
11123 cast<NonTypeTemplateParmDecl>(SecondParam);
11124
11125 QualType FirstType = FirstNTTPD->getType();
11126 QualType SecondType = SecondNTTPD->getType();
11127 if (ComputeQualTypeODRHash(FirstType) !=
11128 ComputeQualTypeODRHash(SecondType)) {
11129 ODRDiagError(FirstTemplate->getLocation(),
11130 FirstTemplate->getSourceRange(),
11131 FunctionTemplateParameterDifferentType)
11132 << FirstTemplate << (i + 1);
11133 ODRDiagNote(SecondTemplate->getLocation(),
11134 SecondTemplate->getSourceRange(),
11135 FunctionTemplateParameterDifferentType)
11136 << SecondTemplate << (i + 1);
11137 ParameterMismatch = true;
11138 break;
11139 }
11140
11141 bool HasFirstDefaultArgument =
11142 FirstNTTPD->hasDefaultArgument() &&
11143 !FirstNTTPD->defaultArgumentWasInherited();
11144 bool HasSecondDefaultArgument =
11145 SecondNTTPD->hasDefaultArgument() &&
11146 !SecondNTTPD->defaultArgumentWasInherited();
11147 if (HasFirstDefaultArgument != HasSecondDefaultArgument) {
11148 ODRDiagError(FirstTemplate->getLocation(),
11149 FirstTemplate->getSourceRange(),
11150 FunctionTemplateParameterSingleDefaultArgument)
11151 << FirstTemplate << (i + 1) << HasFirstDefaultArgument;
11152 ODRDiagNote(SecondTemplate->getLocation(),
11153 SecondTemplate->getSourceRange(),
11154 FunctionTemplateParameterSingleDefaultArgument)
11155 << SecondTemplate << (i + 1) << HasSecondDefaultArgument;
11156 ParameterMismatch = true;
11157 break;
11158 }
11159
11160 if (HasFirstDefaultArgument && HasSecondDefaultArgument) {
11161 Expr *FirstDefaultArgument = FirstNTTPD->getDefaultArgument();
11162 Expr *SecondDefaultArgument = SecondNTTPD->getDefaultArgument();
11163 if (ComputeODRHash(FirstDefaultArgument) !=
11164 ComputeODRHash(SecondDefaultArgument)) {
11165 ODRDiagError(FirstTemplate->getLocation(),
11166 FirstTemplate->getSourceRange(),
11167 FunctionTemplateParameterDifferentDefaultArgument)
11168 << FirstTemplate << (i + 1) << FirstDefaultArgument;
11169 ODRDiagNote(SecondTemplate->getLocation(),
11170 SecondTemplate->getSourceRange(),
11171 FunctionTemplateParameterDifferentDefaultArgument)
11172 << SecondTemplate << (i + 1) << SecondDefaultArgument;
11173 ParameterMismatch = true;
11174 break;
11175 }
11176 }
11177
11178 if (FirstNTTPD->isParameterPack() !=
11179 SecondNTTPD->isParameterPack()) {
11180 ODRDiagError(FirstTemplate->getLocation(),
11181 FirstTemplate->getSourceRange(),
11182 FunctionTemplatePackParameter)
11183 << FirstTemplate << (i + 1) << FirstNTTPD->isParameterPack();
11184 ODRDiagNote(SecondTemplate->getLocation(),
11185 SecondTemplate->getSourceRange(),
11186 FunctionTemplatePackParameter)
11187 << SecondTemplate << (i + 1)
11188 << SecondNTTPD->isParameterPack();
11189 ParameterMismatch = true;
11190 break;
11191 }
11192 }
11193 }
11194
11195 if (ParameterMismatch) {
11196 Diagnosed = true;
11197 break;
11198 }
11199
11200 break;
11201 }
11202 }
11203
11204 if (Diagnosed)
11205 continue;
11206
11207 Diag(FirstDecl->getLocation(),
11208 diag::err_module_odr_violation_mismatch_decl_unknown)
11209 << FirstRecord << FirstModule.empty() << FirstModule << FirstDiffType
11210 << FirstDecl->getSourceRange();
11211 Diag(SecondDecl->getLocation(),
11212 diag::note_module_odr_violation_mismatch_decl_unknown)
11213 << SecondModule << FirstDiffType << SecondDecl->getSourceRange();
11214 Diagnosed = true;
11215 }
11216
11217 if (!Diagnosed) {
11218 // All definitions are updates to the same declaration. This happens if a
11219 // module instantiates the declaration of a class template specialization
11220 // and two or more other modules instantiate its definition.
11221 //
11222 // FIXME: Indicate which modules had instantiations of this definition.
11223 // FIXME: How can this even happen?
11224 Diag(Merge.first->getLocation(),
11225 diag::err_module_odr_violation_different_instantiations)
11226 << Merge.first;
11227 }
11228 }
11229
11230 // Issue ODR failures diagnostics for functions.
11231 for (auto &Merge : FunctionOdrMergeFailures) {
11232 enum ODRFunctionDifference {
11233 ReturnType,
11234 ParameterName,
11235 ParameterType,
11236 ParameterSingleDefaultArgument,
11237 ParameterDifferentDefaultArgument,
11238 FunctionBody,
11239 };
11240
11241 FunctionDecl *FirstFunction = Merge.first;
11242 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstFunction);
11243
11244 bool Diagnosed = false;
11245 for (auto &SecondFunction : Merge.second) {
11246
11247 if (FirstFunction == SecondFunction)
11248 continue;
11249
11250 std::string SecondModule =
11251 getOwningModuleNameForDiagnostic(SecondFunction);
11252
11253 auto ODRDiagError = [FirstFunction, &FirstModule,
11254 this](SourceLocation Loc, SourceRange Range,
11255 ODRFunctionDifference DiffType) {
11256 return Diag(Loc, diag::err_module_odr_violation_function)
11257 << FirstFunction << FirstModule.empty() << FirstModule << Range
11258 << DiffType;
11259 };
11260 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11261 SourceRange Range,
11262 ODRFunctionDifference DiffType) {
11263 return Diag(Loc, diag::note_module_odr_violation_function)
11264 << SecondModule << Range << DiffType;
11265 };
11266
11267 if (ComputeQualTypeODRHash(FirstFunction->getReturnType()) !=
11268 ComputeQualTypeODRHash(SecondFunction->getReturnType())) {
11269 ODRDiagError(FirstFunction->getReturnTypeSourceRange().getBegin(),
11270 FirstFunction->getReturnTypeSourceRange(), ReturnType)
11271 << FirstFunction->getReturnType();
11272 ODRDiagNote(SecondFunction->getReturnTypeSourceRange().getBegin(),
11273 SecondFunction->getReturnTypeSourceRange(), ReturnType)
11274 << SecondFunction->getReturnType();
11275 Diagnosed = true;
11276 break;
11277 }
11278
11279 assert(FirstFunction->param_size() == SecondFunction->param_size() &&((FirstFunction->param_size() == SecondFunction->param_size
() && "Merged functions with different number of parameters"
) ? static_cast<void> (0) : __assert_fail ("FirstFunction->param_size() == SecondFunction->param_size() && \"Merged functions with different number of parameters\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11280, __PRETTY_FUNCTION__))
11280 "Merged functions with different number of parameters")((FirstFunction->param_size() == SecondFunction->param_size
() && "Merged functions with different number of parameters"
) ? static_cast<void> (0) : __assert_fail ("FirstFunction->param_size() == SecondFunction->param_size() && \"Merged functions with different number of parameters\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11280, __PRETTY_FUNCTION__))
;
11281
11282 auto ParamSize = FirstFunction->param_size();
11283 bool ParameterMismatch = false;
11284 for (unsigned I = 0; I < ParamSize; ++I) {
11285 auto *FirstParam = FirstFunction->getParamDecl(I);
11286 auto *SecondParam = SecondFunction->getParamDecl(I);
11287
11288 assert(getContext().hasSameType(FirstParam->getType(),((getContext().hasSameType(FirstParam->getType(), SecondParam
->getType()) && "Merged function has different parameter types."
) ? static_cast<void> (0) : __assert_fail ("getContext().hasSameType(FirstParam->getType(), SecondParam->getType()) && \"Merged function has different parameter types.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11290, __PRETTY_FUNCTION__))
11289 SecondParam->getType()) &&((getContext().hasSameType(FirstParam->getType(), SecondParam
->getType()) && "Merged function has different parameter types."
) ? static_cast<void> (0) : __assert_fail ("getContext().hasSameType(FirstParam->getType(), SecondParam->getType()) && \"Merged function has different parameter types.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11290, __PRETTY_FUNCTION__))
11290 "Merged function has different parameter types.")((getContext().hasSameType(FirstParam->getType(), SecondParam
->getType()) && "Merged function has different parameter types."
) ? static_cast<void> (0) : __assert_fail ("getContext().hasSameType(FirstParam->getType(), SecondParam->getType()) && \"Merged function has different parameter types.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11290, __PRETTY_FUNCTION__))
;
11291
11292 if (FirstParam->getDeclName() != SecondParam->getDeclName()) {
11293 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11294 ParameterName)
11295 << I + 1 << FirstParam->getDeclName();
11296 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11297 ParameterName)
11298 << I + 1 << SecondParam->getDeclName();
11299 ParameterMismatch = true;
11300 break;
11301 };
11302
11303 QualType FirstParamType = FirstParam->getType();
11304 QualType SecondParamType = SecondParam->getType();
11305 if (FirstParamType != SecondParamType &&
11306 ComputeQualTypeODRHash(FirstParamType) !=
11307 ComputeQualTypeODRHash(SecondParamType)) {
11308 if (const DecayedType *ParamDecayedType =
11309 FirstParamType->getAs<DecayedType>()) {
11310 ODRDiagError(FirstParam->getLocation(),
11311 FirstParam->getSourceRange(), ParameterType)
11312 << (I + 1) << FirstParamType << true
11313 << ParamDecayedType->getOriginalType();
11314 } else {
11315 ODRDiagError(FirstParam->getLocation(),
11316 FirstParam->getSourceRange(), ParameterType)
11317 << (I + 1) << FirstParamType << false;
11318 }
11319
11320 if (const DecayedType *ParamDecayedType =
11321 SecondParamType->getAs<DecayedType>()) {
11322 ODRDiagNote(SecondParam->getLocation(),
11323 SecondParam->getSourceRange(), ParameterType)
11324 << (I + 1) << SecondParamType << true
11325 << ParamDecayedType->getOriginalType();
11326 } else {
11327 ODRDiagNote(SecondParam->getLocation(),
11328 SecondParam->getSourceRange(), ParameterType)
11329 << (I + 1) << SecondParamType << false;
11330 }
11331 ParameterMismatch = true;
11332 break;
11333 }
11334
11335 const Expr *FirstInit = FirstParam->getInit();
11336 const Expr *SecondInit = SecondParam->getInit();
11337 if ((FirstInit == nullptr) != (SecondInit == nullptr)) {
11338 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11339 ParameterSingleDefaultArgument)
11340 << (I + 1) << (FirstInit == nullptr)
11341 << (FirstInit ? FirstInit->getSourceRange() : SourceRange());
11342 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11343 ParameterSingleDefaultArgument)
11344 << (I + 1) << (SecondInit == nullptr)
11345 << (SecondInit ? SecondInit->getSourceRange() : SourceRange());
11346 ParameterMismatch = true;
11347 break;
11348 }
11349
11350 if (FirstInit && SecondInit &&
11351 ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11352 ODRDiagError(FirstParam->getLocation(), FirstParam->getSourceRange(),
11353 ParameterDifferentDefaultArgument)
11354 << (I + 1) << FirstInit->getSourceRange();
11355 ODRDiagNote(SecondParam->getLocation(), SecondParam->getSourceRange(),
11356 ParameterDifferentDefaultArgument)
11357 << (I + 1) << SecondInit->getSourceRange();
11358 ParameterMismatch = true;
11359 break;
11360 }
11361
11362 assert(ComputeSubDeclODRHash(FirstParam) ==((ComputeSubDeclODRHash(FirstParam) == ComputeSubDeclODRHash(
SecondParam) && "Undiagnosed parameter difference.") ?
static_cast<void> (0) : __assert_fail ("ComputeSubDeclODRHash(FirstParam) == ComputeSubDeclODRHash(SecondParam) && \"Undiagnosed parameter difference.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11364, __PRETTY_FUNCTION__))
11363 ComputeSubDeclODRHash(SecondParam) &&((ComputeSubDeclODRHash(FirstParam) == ComputeSubDeclODRHash(
SecondParam) && "Undiagnosed parameter difference.") ?
static_cast<void> (0) : __assert_fail ("ComputeSubDeclODRHash(FirstParam) == ComputeSubDeclODRHash(SecondParam) && \"Undiagnosed parameter difference.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11364, __PRETTY_FUNCTION__))
11364 "Undiagnosed parameter difference.")((ComputeSubDeclODRHash(FirstParam) == ComputeSubDeclODRHash(
SecondParam) && "Undiagnosed parameter difference.") ?
static_cast<void> (0) : __assert_fail ("ComputeSubDeclODRHash(FirstParam) == ComputeSubDeclODRHash(SecondParam) && \"Undiagnosed parameter difference.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11364, __PRETTY_FUNCTION__))
;
11365 }
11366
11367 if (ParameterMismatch) {
11368 Diagnosed = true;
11369 break;
11370 }
11371
11372 // If no error has been generated before now, assume the problem is in
11373 // the body and generate a message.
11374 ODRDiagError(FirstFunction->getLocation(),
11375 FirstFunction->getSourceRange(), FunctionBody);
11376 ODRDiagNote(SecondFunction->getLocation(),
11377 SecondFunction->getSourceRange(), FunctionBody);
11378 Diagnosed = true;
11379 break;
11380 }
11381 (void)Diagnosed;
11382 assert(Diagnosed && "Unable to emit ODR diagnostic.")((Diagnosed && "Unable to emit ODR diagnostic.") ? static_cast
<void> (0) : __assert_fail ("Diagnosed && \"Unable to emit ODR diagnostic.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11382, __PRETTY_FUNCTION__))
;
11383 }
11384
11385 // Issue ODR failures diagnostics for enums.
11386 for (auto &Merge : EnumOdrMergeFailures) {
11387 enum ODREnumDifference {
11388 SingleScopedEnum,
11389 EnumTagKeywordMismatch,
11390 SingleSpecifiedType,
11391 DifferentSpecifiedTypes,
11392 DifferentNumberEnumConstants,
11393 EnumConstantName,
11394 EnumConstantSingleInitilizer,
11395 EnumConstantDifferentInitilizer,
11396 };
11397
11398 // If we've already pointed out a specific problem with this enum, don't
11399 // bother issuing a general "something's different" diagnostic.
11400 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
11401 continue;
11402
11403 EnumDecl *FirstEnum = Merge.first;
11404 std::string FirstModule = getOwningModuleNameForDiagnostic(FirstEnum);
11405
11406 using DeclHashes =
11407 llvm::SmallVector<std::pair<EnumConstantDecl *, unsigned>, 4>;
11408 auto PopulateHashes = [&ComputeSubDeclODRHash, FirstEnum](
11409 DeclHashes &Hashes, EnumDecl *Enum) {
11410 for (auto *D : Enum->decls()) {
11411 // Due to decl merging, the first EnumDecl is the parent of
11412 // Decls in both records.
11413 if (!ODRHash::isWhitelistedDecl(D, FirstEnum))
11414 continue;
11415 assert(isa<EnumConstantDecl>(D) && "Unexpected Decl kind")((isa<EnumConstantDecl>(D) && "Unexpected Decl kind"
) ? static_cast<void> (0) : __assert_fail ("isa<EnumConstantDecl>(D) && \"Unexpected Decl kind\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11415, __PRETTY_FUNCTION__))
;
11416 Hashes.emplace_back(cast<EnumConstantDecl>(D),
11417 ComputeSubDeclODRHash(D));
11418 }
11419 };
11420 DeclHashes FirstHashes;
11421 PopulateHashes(FirstHashes, FirstEnum);
11422 bool Diagnosed = false;
11423 for (auto &SecondEnum : Merge.second) {
11424
11425 if (FirstEnum == SecondEnum)
11426 continue;
11427
11428 std::string SecondModule =
11429 getOwningModuleNameForDiagnostic(SecondEnum);
11430
11431 auto ODRDiagError = [FirstEnum, &FirstModule,
11432 this](SourceLocation Loc, SourceRange Range,
11433 ODREnumDifference DiffType) {
11434 return Diag(Loc, diag::err_module_odr_violation_enum)
11435 << FirstEnum << FirstModule.empty() << FirstModule << Range
11436 << DiffType;
11437 };
11438 auto ODRDiagNote = [&SecondModule, this](SourceLocation Loc,
11439 SourceRange Range,
11440 ODREnumDifference DiffType) {
11441 return Diag(Loc, diag::note_module_odr_violation_enum)
11442 << SecondModule << Range << DiffType;
11443 };
11444
11445 if (FirstEnum->isScoped() != SecondEnum->isScoped()) {
11446 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11447 SingleScopedEnum)
11448 << FirstEnum->isScoped();
11449 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11450 SingleScopedEnum)
11451 << SecondEnum->isScoped();
11452 Diagnosed = true;
11453 continue;
11454 }
11455
11456 if (FirstEnum->isScoped() && SecondEnum->isScoped()) {
11457 if (FirstEnum->isScopedUsingClassTag() !=
11458 SecondEnum->isScopedUsingClassTag()) {
11459 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11460 EnumTagKeywordMismatch)
11461 << FirstEnum->isScopedUsingClassTag();
11462 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11463 EnumTagKeywordMismatch)
11464 << SecondEnum->isScopedUsingClassTag();
11465 Diagnosed = true;
11466 continue;
11467 }
11468 }
11469
11470 QualType FirstUnderlyingType =
11471 FirstEnum->getIntegerTypeSourceInfo()
11472 ? FirstEnum->getIntegerTypeSourceInfo()->getType()
11473 : QualType();
11474 QualType SecondUnderlyingType =
11475 SecondEnum->getIntegerTypeSourceInfo()
11476 ? SecondEnum->getIntegerTypeSourceInfo()->getType()
11477 : QualType();
11478 if (FirstUnderlyingType.isNull() != SecondUnderlyingType.isNull()) {
11479 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11480 SingleSpecifiedType)
11481 << !FirstUnderlyingType.isNull();
11482 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11483 SingleSpecifiedType)
11484 << !SecondUnderlyingType.isNull();
11485 Diagnosed = true;
11486 continue;
11487 }
11488
11489 if (!FirstUnderlyingType.isNull() && !SecondUnderlyingType.isNull()) {
11490 if (ComputeQualTypeODRHash(FirstUnderlyingType) !=
11491 ComputeQualTypeODRHash(SecondUnderlyingType)) {
11492 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11493 DifferentSpecifiedTypes)
11494 << FirstUnderlyingType;
11495 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11496 DifferentSpecifiedTypes)
11497 << SecondUnderlyingType;
11498 Diagnosed = true;
11499 continue;
11500 }
11501 }
11502
11503 DeclHashes SecondHashes;
11504 PopulateHashes(SecondHashes, SecondEnum);
11505
11506 if (FirstHashes.size() != SecondHashes.size()) {
11507 ODRDiagError(FirstEnum->getLocation(), FirstEnum->getSourceRange(),
11508 DifferentNumberEnumConstants)
11509 << (int)FirstHashes.size();
11510 ODRDiagNote(SecondEnum->getLocation(), SecondEnum->getSourceRange(),
11511 DifferentNumberEnumConstants)
11512 << (int)SecondHashes.size();
11513 Diagnosed = true;
11514 continue;
11515 }
11516
11517 for (unsigned I = 0; I < FirstHashes.size(); ++I) {
11518 if (FirstHashes[I].second == SecondHashes[I].second)
11519 continue;
11520 const EnumConstantDecl *FirstEnumConstant = FirstHashes[I].first;
11521 const EnumConstantDecl *SecondEnumConstant = SecondHashes[I].first;
11522
11523 if (FirstEnumConstant->getDeclName() !=
11524 SecondEnumConstant->getDeclName()) {
11525
11526 ODRDiagError(FirstEnumConstant->getLocation(),
11527 FirstEnumConstant->getSourceRange(), EnumConstantName)
11528 << I + 1 << FirstEnumConstant;
11529 ODRDiagNote(SecondEnumConstant->getLocation(),
11530 SecondEnumConstant->getSourceRange(), EnumConstantName)
11531 << I + 1 << SecondEnumConstant;
11532 Diagnosed = true;
11533 break;
11534 }
11535
11536 const Expr *FirstInit = FirstEnumConstant->getInitExpr();
11537 const Expr *SecondInit = SecondEnumConstant->getInitExpr();
11538 if (!FirstInit && !SecondInit)
11539 continue;
11540
11541 if (!FirstInit || !SecondInit) {
11542 ODRDiagError(FirstEnumConstant->getLocation(),
11543 FirstEnumConstant->getSourceRange(),
11544 EnumConstantSingleInitilizer)
11545 << I + 1 << FirstEnumConstant << (FirstInit != nullptr);
11546 ODRDiagNote(SecondEnumConstant->getLocation(),
11547 SecondEnumConstant->getSourceRange(),
11548 EnumConstantSingleInitilizer)
11549 << I + 1 << SecondEnumConstant << (SecondInit != nullptr);
11550 Diagnosed = true;
11551 break;
11552 }
11553
11554 if (ComputeODRHash(FirstInit) != ComputeODRHash(SecondInit)) {
11555 ODRDiagError(FirstEnumConstant->getLocation(),
11556 FirstEnumConstant->getSourceRange(),
11557 EnumConstantDifferentInitilizer)
11558 << I + 1 << FirstEnumConstant;
11559 ODRDiagNote(SecondEnumConstant->getLocation(),
11560 SecondEnumConstant->getSourceRange(),
11561 EnumConstantDifferentInitilizer)
11562 << I + 1 << SecondEnumConstant;
11563 Diagnosed = true;
11564 break;
11565 }
11566 }
11567 }
11568
11569 (void)Diagnosed;
11570 assert(Diagnosed && "Unable to emit ODR diagnostic.")((Diagnosed && "Unable to emit ODR diagnostic.") ? static_cast
<void> (0) : __assert_fail ("Diagnosed && \"Unable to emit ODR diagnostic.\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11570, __PRETTY_FUNCTION__))
;
11571 }
11572}
11573
11574void ASTReader::StartedDeserializing() {
11575 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
11576 ReadTimer->startTimer();
11577}
11578
11579void ASTReader::FinishedDeserializing() {
11580 assert(NumCurrentElementsDeserializing &&((NumCurrentElementsDeserializing && "FinishedDeserializing not paired with StartedDeserializing"
) ? static_cast<void> (0) : __assert_fail ("NumCurrentElementsDeserializing && \"FinishedDeserializing not paired with StartedDeserializing\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11581, __PRETTY_FUNCTION__))
11581 "FinishedDeserializing not paired with StartedDeserializing")((NumCurrentElementsDeserializing && "FinishedDeserializing not paired with StartedDeserializing"
) ? static_cast<void> (0) : __assert_fail ("NumCurrentElementsDeserializing && \"FinishedDeserializing not paired with StartedDeserializing\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Serialization/ASTReader.cpp"
, 11581, __PRETTY_FUNCTION__))
;
11582 if (NumCurrentElementsDeserializing == 1) {
11583 // We decrease NumCurrentElementsDeserializing only after pending actions
11584 // are finished, to avoid recursively re-calling finishPendingActions().
11585 finishPendingActions();
11586 }
11587 --NumCurrentElementsDeserializing;
11588
11589 if (NumCurrentElementsDeserializing == 0) {
11590 // Propagate exception specification and deduced type updates along
11591 // redeclaration chains.
11592 //
11593 // We do this now rather than in finishPendingActions because we want to
11594 // be able to walk the complete redeclaration chains of the updated decls.
11595 while (!PendingExceptionSpecUpdates.empty() ||
11596 !PendingDeducedTypeUpdates.empty()) {
11597 auto ESUpdates = std::move(PendingExceptionSpecUpdates);
11598 PendingExceptionSpecUpdates.clear();
11599 for (auto Update : ESUpdates) {
11600 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11601 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
11602 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
11603 if (auto *Listener = getContext().getASTMutationListener())
11604 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
11605 for (auto *Redecl : Update.second->redecls())
11606 getContext().adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
11607 }
11608
11609 auto DTUpdates = std::move(PendingDeducedTypeUpdates);
11610 PendingDeducedTypeUpdates.clear();
11611 for (auto Update : DTUpdates) {
11612 ProcessingUpdatesRAIIObj ProcessingUpdates(*this);
11613 // FIXME: If the return type is already deduced, check that it matches.
11614 getContext().adjustDeducedFunctionResultType(Update.first,
11615 Update.second);
11616 }
11617 }
11618
11619 if (ReadTimer)
11620 ReadTimer->stopTimer();
11621
11622 diagnoseOdrViolations();
11623
11624 // We are not in recursive loading, so it's safe to pass the "interesting"
11625 // decls to the consumer.
11626 if (Consumer)
11627 PassInterestingDeclsToConsumer();
11628 }
11629}
11630
11631void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
11632 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
11633 // Remove any fake results before adding any real ones.
11634 auto It = PendingFakeLookupResults.find(II);
11635 if (It != PendingFakeLookupResults.end()) {
11636 for (auto *ND : It->second)
11637 SemaObj->IdResolver.RemoveDecl(ND);
11638 // FIXME: this works around module+PCH performance issue.
11639 // Rather than erase the result from the map, which is O(n), just clear
11640 // the vector of NamedDecls.
11641 It->second.clear();
11642 }
11643 }
11644
11645 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
11646 SemaObj->TUScope->AddDecl(D);
11647 } else if (SemaObj->TUScope) {
11648 // Adding the decl to IdResolver may have failed because it was already in
11649 // (even though it was not added in scope). If it is already in, make sure
11650 // it gets in the scope as well.
11651 if (std::find(SemaObj->IdResolver.begin(Name),
11652 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
11653 SemaObj->TUScope->AddDecl(D);
11654 }
11655}
11656
11657ASTReader::ASTReader(Preprocessor &PP, InMemoryModuleCache &ModuleCache,
11658 ASTContext *Context,
11659 const PCHContainerReader &PCHContainerRdr,
11660 ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
11661 StringRef isysroot, bool DisableValidation,
11662 bool AllowASTWithCompilerErrors,
11663 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
11664 bool UseGlobalIndex,
11665 std::unique_ptr<llvm::Timer> ReadTimer)
11666 : Listener(DisableValidation
11667 ? cast<ASTReaderListener>(new SimpleASTReaderListener(PP))
11668 : cast<ASTReaderListener>(new PCHValidator(PP, *this))),
11669 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()),
11670 PCHContainerRdr(PCHContainerRdr), Diags(PP.getDiagnostics()), PP(PP),
11671 ContextObj(Context), ModuleMgr(PP.getFileManager(), ModuleCache,
11672 PCHContainerRdr, PP.getHeaderSearchInfo()),
11673 DummyIdResolver(PP), ReadTimer(std::move(ReadTimer)), isysroot(isysroot),
11674 DisableValidation(DisableValidation),
11675 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
11676 AllowConfigurationMismatch(AllowConfigurationMismatch),
11677 ValidateSystemInputs(ValidateSystemInputs),
11678 UseGlobalIndex(UseGlobalIndex), CurrSwitchCaseStmts(&SwitchCaseStmts) {
11679 SourceMgr.setExternalSLocEntrySource(this);
11680
11681 for (const auto &Ext : Extensions) {
11682 auto BlockName = Ext->getExtensionMetadata().BlockName;
11683 auto Known = ModuleFileExtensions.find(BlockName);
11684 if (Known != ModuleFileExtensions.end()) {
11685 Diags.Report(diag::warn_duplicate_module_file_extension)
11686 << BlockName;
11687 continue;
11688 }
11689
11690 ModuleFileExtensions.insert({BlockName, Ext});
11691 }
11692}
11693
11694ASTReader::~ASTReader() {
11695 if (OwnsDeserializationListener)
11696 delete DeserializationListener;
11697}
11698
11699IdentifierResolver &ASTReader::getIdResolver() {
11700 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
11701}
11702
11703unsigned ASTRecordReader::readRecord(llvm::BitstreamCursor &Cursor,
11704 unsigned AbbrevID) {
11705 Idx = 0;
11706 Record.clear();
11707 return Cursor.readRecord(AbbrevID, Record);
11708}
11709//===----------------------------------------------------------------------===//
11710//// OMPClauseReader implementation
11711////===----------------------------------------------------------------------===//
11712
11713OMPClause *OMPClauseReader::readClause() {
11714 OMPClause *C;
11715 switch (Record.readInt()) {
11716 case OMPC_if:
11717 C = new (Context) OMPIfClause();
11718 break;
11719 case OMPC_final:
11720 C = new (Context) OMPFinalClause();
11721 break;
11722 case OMPC_num_threads:
11723 C = new (Context) OMPNumThreadsClause();
11724 break;
11725 case OMPC_safelen:
11726 C = new (Context) OMPSafelenClause();
11727 break;
11728 case OMPC_simdlen:
11729 C = new (Context) OMPSimdlenClause();
11730 break;
11731 case OMPC_allocator:
11732 C = new (Context) OMPAllocatorClause();
11733 break;
11734 case OMPC_collapse:
11735 C = new (Context) OMPCollapseClause();
11736 break;
11737 case OMPC_default:
11738 C = new (Context) OMPDefaultClause();
11739 break;
11740 case OMPC_proc_bind:
11741 C = new (Context) OMPProcBindClause();
11742 break;
11743 case OMPC_schedule:
11744 C = new (Context) OMPScheduleClause();
11745 break;
11746 case OMPC_ordered:
11747 C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
11748 break;
11749 case OMPC_nowait:
11750 C = new (Context) OMPNowaitClause();
11751 break;
11752 case OMPC_untied:
11753 C = new (Context) OMPUntiedClause();
11754 break;
11755 case OMPC_mergeable:
11756 C = new (Context) OMPMergeableClause();
11757 break;
11758 case OMPC_read:
11759 C = new (Context) OMPReadClause();
11760 break;
11761 case OMPC_write:
11762 C = new (Context) OMPWriteClause();
11763 break;
11764 case OMPC_update:
11765 C = new (Context) OMPUpdateClause();
11766 break;
11767 case OMPC_capture:
11768 C = new (Context) OMPCaptureClause();
11769 break;
11770 case OMPC_seq_cst:
11771 C = new (Context) OMPSeqCstClause();
11772 break;
11773 case OMPC_threads:
11774 C = new (Context) OMPThreadsClause();
11775 break;
11776 case OMPC_simd:
11777 C = new (Context) OMPSIMDClause();
11778 break;
11779 case OMPC_nogroup:
11780 C = new (Context) OMPNogroupClause();
11781 break;
11782 case OMPC_unified_address:
11783 C = new (Context) OMPUnifiedAddressClause();
11784 break;
11785 case OMPC_unified_shared_memory:
11786 C = new (Context) OMPUnifiedSharedMemoryClause();
11787 break;
11788 case OMPC_reverse_offload:
11789 C = new (Context) OMPReverseOffloadClause();
11790 break;
11791 case OMPC_dynamic_allocators:
11792 C = new (Context) OMPDynamicAllocatorsClause();
11793 break;
11794 case OMPC_atomic_default_mem_order:
11795 C = new (Context) OMPAtomicDefaultMemOrderClause();
11796 break;
11797 case OMPC_private:
11798 C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
11799 break;
11800 case OMPC_firstprivate:
11801 C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
11802 break;
11803 case OMPC_lastprivate:
11804 C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
11805 break;
11806 case OMPC_shared:
11807 C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
11808 break;
11809 case OMPC_reduction:
11810 C = OMPReductionClause::CreateEmpty(Context, Record.readInt());
11811 break;
11812 case OMPC_task_reduction:
11813 C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
11814 break;
11815 case OMPC_in_reduction:
11816 C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
11817 break;
11818 case OMPC_linear:
11819 C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
11820 break;
11821 case OMPC_aligned:
11822 C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
11823 break;
11824 case OMPC_copyin:
11825 C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
11826 break;
11827 case OMPC_copyprivate:
11828 C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
11829 break;
11830 case OMPC_flush:
11831 C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
11832 break;
11833 case OMPC_depend: {
11834 unsigned NumVars = Record.readInt();
11835 unsigned NumLoops = Record.readInt();
11836 C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
11837 break;
11838 }
11839 case OMPC_device:
11840 C = new (Context) OMPDeviceClause();
11841 break;
11842 case OMPC_map: {
11843 OMPMappableExprListSizeTy Sizes;
11844 Sizes.NumVars = Record.readInt();
11845 Sizes.NumUniqueDeclarations = Record.readInt();
11846 Sizes.NumComponentLists = Record.readInt();
11847 Sizes.NumComponents = Record.readInt();
11848 C = OMPMapClause::CreateEmpty(Context, Sizes);
11849 break;
11850 }
11851 case OMPC_num_teams:
11852 C = new (Context) OMPNumTeamsClause();
11853 break;
11854 case OMPC_thread_limit:
11855 C = new (Context) OMPThreadLimitClause();
11856 break;
11857 case OMPC_priority:
11858 C = new (Context) OMPPriorityClause();
11859 break;
11860 case OMPC_grainsize:
11861 C = new (Context) OMPGrainsizeClause();
11862 break;
11863 case OMPC_num_tasks:
11864 C = new (Context) OMPNumTasksClause();
11865 break;
11866 case OMPC_hint:
11867 C = new (Context) OMPHintClause();
11868 break;
11869 case OMPC_dist_schedule:
11870 C = new (Context) OMPDistScheduleClause();
11871 break;
11872 case OMPC_defaultmap:
11873 C = new (Context) OMPDefaultmapClause();
11874 break;
11875 case OMPC_to: {
11876 OMPMappableExprListSizeTy Sizes;
11877 Sizes.NumVars = Record.readInt();
11878 Sizes.NumUniqueDeclarations = Record.readInt();
11879 Sizes.NumComponentLists = Record.readInt();
11880 Sizes.NumComponents = Record.readInt();
11881 C = OMPToClause::CreateEmpty(Context, Sizes);
11882 break;
11883 }
11884 case OMPC_from: {
11885 OMPMappableExprListSizeTy Sizes;
11886 Sizes.NumVars = Record.readInt();
11887 Sizes.NumUniqueDeclarations = Record.readInt();
11888 Sizes.NumComponentLists = Record.readInt();
11889 Sizes.NumComponents = Record.readInt();
11890 C = OMPFromClause::CreateEmpty(Context, Sizes);
11891 break;
11892 }
11893 case OMPC_use_device_ptr: {
11894 OMPMappableExprListSizeTy Sizes;
11895 Sizes.NumVars = Record.readInt();
11896 Sizes.NumUniqueDeclarations = Record.readInt();
11897 Sizes.NumComponentLists = Record.readInt();
11898 Sizes.NumComponents = Record.readInt();
11899 C = OMPUseDevicePtrClause::CreateEmpty(Context, Sizes);
11900 break;
11901 }
11902 case OMPC_is_device_ptr: {
11903 OMPMappableExprListSizeTy Sizes;
11904 Sizes.NumVars = Record.readInt();
11905 Sizes.NumUniqueDeclarations = Record.readInt();
11906 Sizes.NumComponentLists = Record.readInt();
11907 Sizes.NumComponents = Record.readInt();
11908 C = OMPIsDevicePtrClause::CreateEmpty(Context, Sizes);
11909 break;
11910 }
11911 case OMPC_allocate:
11912 C = OMPAllocateClause::CreateEmpty(Context, Record.readInt());
11913 break;
11914 }
11915 Visit(C);
11916 C->setLocStart(Record.readSourceLocation());
11917 C->setLocEnd(Record.readSourceLocation());
11918
11919 return C;
11920}
11921
11922void OMPClauseReader::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
11923 C->setPreInitStmt(Record.readSubStmt(),
11924 static_cast<OpenMPDirectiveKind>(Record.readInt()));
11925}
11926
11927void OMPClauseReader::VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C) {
11928 VisitOMPClauseWithPreInit(C);
11929 C->setPostUpdateExpr(Record.readSubExpr());
11930}
11931
11932void OMPClauseReader::VisitOMPIfClause(OMPIfClause *C) {
11933 VisitOMPClauseWithPreInit(C);
11934 C->setNameModifier(static_cast<OpenMPDirectiveKind>(Record.readInt()));
11935 C->setNameModifierLoc(Record.readSourceLocation());
11936 C->setColonLoc(Record.readSourceLocation());
11937 C->setCondition(Record.readSubExpr());
11938 C->setLParenLoc(Record.readSourceLocation());
11939}
11940
11941void OMPClauseReader::VisitOMPFinalClause(OMPFinalClause *C) {
11942 C->setCondition(Record.readSubExpr());
11943 C->setLParenLoc(Record.readSourceLocation());
11944}
11945
11946void OMPClauseReader::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
11947 VisitOMPClauseWithPreInit(C);
11948 C->setNumThreads(Record.readSubExpr());
11949 C->setLParenLoc(Record.readSourceLocation());
11950}
11951
11952void OMPClauseReader::VisitOMPSafelenClause(OMPSafelenClause *C) {
11953 C->setSafelen(Record.readSubExpr());
11954 C->setLParenLoc(Record.readSourceLocation());
11955}
11956
11957void OMPClauseReader::VisitOMPSimdlenClause(OMPSimdlenClause *C) {
11958 C->setSimdlen(Record.readSubExpr());
11959 C->setLParenLoc(Record.readSourceLocation());
11960}
11961
11962void OMPClauseReader::VisitOMPAllocatorClause(OMPAllocatorClause *C) {
11963 C->setAllocator(Record.readExpr());
11964 C->setLParenLoc(Record.readSourceLocation());
11965}
11966
11967void OMPClauseReader::VisitOMPCollapseClause(OMPCollapseClause *C) {
11968 C->setNumForLoops(Record.readSubExpr());
11969 C->setLParenLoc(Record.readSourceLocation());
11970}
11971
11972void OMPClauseReader::VisitOMPDefaultClause(OMPDefaultClause *C) {
11973 C->setDefaultKind(
11974 static_cast<OpenMPDefaultClauseKind>(Record.readInt()));
11975 C->setLParenLoc(Record.readSourceLocation());
11976 C->setDefaultKindKwLoc(Record.readSourceLocation());
11977}
11978
11979void OMPClauseReader::VisitOMPProcBindClause(OMPProcBindClause *C) {
11980 C->setProcBindKind(
11981 static_cast<OpenMPProcBindClauseKind>(Record.readInt()));
11982 C->setLParenLoc(Record.readSourceLocation());
11983 C->setProcBindKindKwLoc(Record.readSourceLocation());
11984}
11985
11986void OMPClauseReader::VisitOMPScheduleClause(OMPScheduleClause *C) {
11987 VisitOMPClauseWithPreInit(C);
11988 C->setScheduleKind(
11989 static_cast<OpenMPScheduleClauseKind>(Record.readInt()));
11990 C->setFirstScheduleModifier(
11991 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
11992 C->setSecondScheduleModifier(
11993 static_cast<OpenMPScheduleClauseModifier>(Record.readInt()));
11994 C->setChunkSize(Record.readSubExpr());
11995 C->setLParenLoc(Record.readSourceLocation());
11996 C->setFirstScheduleModifierLoc(Record.readSourceLocation());
11997 C->setSecondScheduleModifierLoc(Record.readSourceLocation());
11998 C->setScheduleKindLoc(Record.readSourceLocation());
11999 C->setCommaLoc(Record.readSourceLocation());
12000}
12001
12002void OMPClauseReader::VisitOMPOrderedClause(OMPOrderedClause *C) {
12003 C->setNumForLoops(Record.readSubExpr());
12004 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12005 C->setLoopNumIterations(I, Record.readSubExpr());
12006 for (unsigned I = 0, E = C->NumberOfLoops; I < E; ++I)
12007 C->setLoopCounter(I, Record.readSubExpr());
12008 C->setLParenLoc(Record.readSourceLocation());
12009}
12010
12011void OMPClauseReader::VisitOMPNowaitClause(OMPNowaitClause *) {}
12012
12013void OMPClauseReader::VisitOMPUntiedClause(OMPUntiedClause *) {}
12014
12015void OMPClauseReader::VisitOMPMergeableClause(OMPMergeableClause *) {}
12016
12017void OMPClauseReader::VisitOMPReadClause(OMPReadClause *) {}
12018
12019void OMPClauseReader::VisitOMPWriteClause(OMPWriteClause *) {}
12020
12021void OMPClauseReader::VisitOMPUpdateClause(OMPUpdateClause *) {}
12022
12023void OMPClauseReader::VisitOMPCaptureClause(OMPCaptureClause *) {}
12024
12025void OMPClauseReader::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
12026
12027void OMPClauseReader::VisitOMPThreadsClause(OMPThreadsClause *) {}
12028
12029void OMPClauseReader::VisitOMPSIMDClause(OMPSIMDClause *) {}
12030
12031void OMPClauseReader::VisitOMPNogroupClause(OMPNogroupClause *) {}
12032
12033void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
12034
12035void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
12036 OMPUnifiedSharedMemoryClause *) {}
12037
12038void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
12039
12040void
12041OMPClauseReader::VisitOMPDynamicAllocatorsClause(OMPDynamicAllocatorsClause *) {
12042}
12043
12044void OMPClauseReader::VisitOMPAtomicDefaultMemOrderClause(
12045 OMPAtomicDefaultMemOrderClause *C) {
12046 C->setAtomicDefaultMemOrderKind(
12047 static_cast<OpenMPAtomicDefaultMemOrderClauseKind>(Record.readInt()));
12048 C->setLParenLoc(Record.readSourceLocation());
12049 C->setAtomicDefaultMemOrderKindKwLoc(Record.readSourceLocation());
12050}
12051
12052void OMPClauseReader::VisitOMPPrivateClause(OMPPrivateClause *C) {
12053 C->setLParenLoc(Record.readSourceLocation());
12054 unsigned NumVars = C->varlist_size();
12055 SmallVector<Expr *, 16> Vars;
12056 Vars.reserve(NumVars);
12057 for (unsigned i = 0; i != NumVars; ++i)
12058 Vars.push_back(Record.readSubExpr());
12059 C->setVarRefs(Vars);
12060 Vars.clear();
12061 for (unsigned i = 0; i != NumVars; ++i)
12062 Vars.push_back(Record.readSubExpr());
12063 C->setPrivateCopies(Vars);
12064}
12065
12066void OMPClauseReader::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
12067 VisitOMPClauseWithPreInit(C);
12068 C->setLParenLoc(Record.readSourceLocation());
12069 unsigned NumVars = C->varlist_size();
12070 SmallVector<Expr *, 16> Vars;
12071 Vars.reserve(NumVars);
12072 for (unsigned i = 0; i != NumVars; ++i)
12073 Vars.push_back(Record.readSubExpr());
12074 C->setVarRefs(Vars);
12075 Vars.clear();
12076 for (unsigned i = 0; i != NumVars; ++i)
12077 Vars.push_back(Record.readSubExpr());
12078 C->setPrivateCopies(Vars);
12079 Vars.clear();
12080 for (unsigned i = 0; i != NumVars; ++i)
12081 Vars.push_back(Record.readSubExpr());
12082 C->setInits(Vars);
12083}
12084
12085void OMPClauseReader::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
12086 VisitOMPClauseWithPostUpdate(C);
12087 C->setLParenLoc(Record.readSourceLocation());
12088 unsigned NumVars = C->varlist_size();
12089 SmallVector<Expr *, 16> Vars;
12090 Vars.reserve(NumVars);
12091 for (unsigned i = 0; i != NumVars; ++i)
12092 Vars.push_back(Record.readSubExpr());
12093 C->setVarRefs(Vars);
12094 Vars.clear();
12095 for (unsigned i = 0; i != NumVars; ++i)
12096 Vars.push_back(Record.readSubExpr());
12097 C->setPrivateCopies(Vars);
12098 Vars.clear();
12099 for (unsigned i = 0; i != NumVars; ++i)
12100 Vars.push_back(Record.readSubExpr());
12101 C->setSourceExprs(Vars);
12102 Vars.clear();
12103 for (unsigned i = 0; i != NumVars; ++i)
12104 Vars.push_back(Record.readSubExpr());
12105 C->setDestinationExprs(Vars);
12106 Vars.clear();
12107 for (unsigned i = 0; i != NumVars; ++i)
12108 Vars.push_back(Record.readSubExpr());
12109 C->setAssignmentOps(Vars);
12110}
12111
12112void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
12113 C->setLParenLoc(Record.readSourceLocation());
12114 unsigned NumVars = C->varlist_size();
12115 SmallVector<Expr *, 16> Vars;
12116 Vars.reserve(NumVars);
12117 for (unsigned i = 0; i != NumVars; ++i)
12118 Vars.push_back(Record.readSubExpr());
12119 C->setVarRefs(Vars);
12120}
12121
12122void OMPClauseReader::VisitOMPReductionClause(OMPReductionClause *C) {
12123 VisitOMPClauseWithPostUpdate(C);
12124 C->setLParenLoc(Record.readSourceLocation());
12125 C->setColonLoc(Record.readSourceLocation());
12126 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12127 DeclarationNameInfo DNI;
12128 Record.readDeclarationNameInfo(DNI);
12129 C->setQualifierLoc(NNSL);
12130 C->setNameInfo(DNI);
12131
12132 unsigned NumVars = C->varlist_size();
12133 SmallVector<Expr *, 16> Vars;
12134 Vars.reserve(NumVars);
12135 for (unsigned i = 0; i != NumVars; ++i)
12136 Vars.push_back(Record.readSubExpr());
12137 C->setVarRefs(Vars);
12138 Vars.clear();
12139 for (unsigned i = 0; i != NumVars; ++i)
12140 Vars.push_back(Record.readSubExpr());
12141 C->setPrivates(Vars);
12142 Vars.clear();
12143 for (unsigned i = 0; i != NumVars; ++i)
12144 Vars.push_back(Record.readSubExpr());
12145 C->setLHSExprs(Vars);
12146 Vars.clear();
12147 for (unsigned i = 0; i != NumVars; ++i)
12148 Vars.push_back(Record.readSubExpr());
12149 C->setRHSExprs(Vars);
12150 Vars.clear();
12151 for (unsigned i = 0; i != NumVars; ++i)
12152 Vars.push_back(Record.readSubExpr());
12153 C->setReductionOps(Vars);
12154}
12155
12156void OMPClauseReader::VisitOMPTaskReductionClause(OMPTaskReductionClause *C) {
12157 VisitOMPClauseWithPostUpdate(C);
12158 C->setLParenLoc(Record.readSourceLocation());
12159 C->setColonLoc(Record.readSourceLocation());
12160 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12161 DeclarationNameInfo DNI;
12162 Record.readDeclarationNameInfo(DNI);
12163 C->setQualifierLoc(NNSL);
12164 C->setNameInfo(DNI);
12165
12166 unsigned NumVars = C->varlist_size();
12167 SmallVector<Expr *, 16> Vars;
12168 Vars.reserve(NumVars);
12169 for (unsigned I = 0; I != NumVars; ++I)
12170 Vars.push_back(Record.readSubExpr());
12171 C->setVarRefs(Vars);
12172 Vars.clear();
12173 for (unsigned I = 0; I != NumVars; ++I)
12174 Vars.push_back(Record.readSubExpr());
12175 C->setPrivates(Vars);
12176 Vars.clear();
12177 for (unsigned I = 0; I != NumVars; ++I)
12178 Vars.push_back(Record.readSubExpr());
12179 C->setLHSExprs(Vars);
12180 Vars.clear();
12181 for (unsigned I = 0; I != NumVars; ++I)
12182 Vars.push_back(Record.readSubExpr());
12183 C->setRHSExprs(Vars);
12184 Vars.clear();
12185 for (unsigned I = 0; I != NumVars; ++I)
12186 Vars.push_back(Record.readSubExpr());
12187 C->setReductionOps(Vars);
12188}
12189
12190void OMPClauseReader::VisitOMPInReductionClause(OMPInReductionClause *C) {
12191 VisitOMPClauseWithPostUpdate(C);
12192 C->setLParenLoc(Record.readSourceLocation());
12193 C->setColonLoc(Record.readSourceLocation());
12194 NestedNameSpecifierLoc NNSL = Record.readNestedNameSpecifierLoc();
12195 DeclarationNameInfo DNI;
12196 Record.readDeclarationNameInfo(DNI);
12197 C->setQualifierLoc(NNSL);
12198 C->setNameInfo(DNI);
12199
12200 unsigned NumVars = C->varlist_size();
12201 SmallVector<Expr *, 16> Vars;
12202 Vars.reserve(NumVars);
12203 for (unsigned I = 0; I != NumVars; ++I)
12204 Vars.push_back(Record.readSubExpr());
12205 C->setVarRefs(Vars);
12206 Vars.clear();
12207 for (unsigned I = 0; I != NumVars; ++I)
12208 Vars.push_back(Record.readSubExpr());
12209 C->setPrivates(Vars);
12210 Vars.clear();
12211 for (unsigned I = 0; I != NumVars; ++I)
12212 Vars.push_back(Record.readSubExpr());
12213 C->setLHSExprs(Vars);
12214 Vars.clear();
12215 for (unsigned I = 0; I != NumVars; ++I)
12216 Vars.push_back(Record.readSubExpr());
12217 C->setRHSExprs(Vars);
12218 Vars.clear();
12219 for (unsigned I = 0; I != NumVars; ++I)
12220 Vars.push_back(Record.readSubExpr());
12221 C->setReductionOps(Vars);
12222 Vars.clear();
12223 for (unsigned I = 0; I != NumVars; ++I)
12224 Vars.push_back(Record.readSubExpr());
12225 C->setTaskgroupDescriptors(Vars);
12226}
12227
12228void OMPClauseReader::VisitOMPLinearClause(OMPLinearClause *C) {
12229 VisitOMPClauseWithPostUpdate(C);
12230 C->setLParenLoc(Record.readSourceLocation());
12231 C->setColonLoc(Record.readSourceLocation());
12232 C->setModifier(static_cast<OpenMPLinearClauseKind>(Record.readInt()));
12233 C->setModifierLoc(Record.readSourceLocation());
12234 unsigned NumVars = C->varlist_size();
12235 SmallVector<Expr *, 16> Vars;
12236 Vars.reserve(NumVars);
12237 for (unsigned i = 0; i != NumVars; ++i)
12238 Vars.push_back(Record.readSubExpr());
12239 C->setVarRefs(Vars);
12240 Vars.clear();
12241 for (unsigned i = 0; i != NumVars; ++i)
12242 Vars.push_back(Record.readSubExpr());
12243 C->setPrivates(Vars);
12244 Vars.clear();
12245 for (unsigned i = 0; i != NumVars; ++i)
12246 Vars.push_back(Record.readSubExpr());
12247 C->setInits(Vars);
12248 Vars.clear();
12249 for (unsigned i = 0; i != NumVars; ++i)
12250 Vars.push_back(Record.readSubExpr());
12251 C->setUpdates(Vars);
12252 Vars.clear();
12253 for (unsigned i = 0; i != NumVars; ++i)
12254 Vars.push_back(Record.readSubExpr());
12255 C->setFinals(Vars);
12256 C->setStep(Record.readSubExpr());
12257 C->setCalcStep(Record.readSubExpr());
12258}
12259
12260void OMPClauseReader::VisitOMPAlignedClause(OMPAlignedClause *C) {
12261 C->setLParenLoc(Record.readSourceLocation());
12262 C->setColonLoc(Record.readSourceLocation());
12263 unsigned NumVars = C->varlist_size();
12264 SmallVector<Expr *, 16> Vars;
12265 Vars.reserve(NumVars);
12266 for (unsigned i = 0; i != NumVars; ++i)
12267 Vars.push_back(Record.readSubExpr());
12268 C->setVarRefs(Vars);
12269 C->setAlignment(Record.readSubExpr());
12270}
12271
12272void OMPClauseReader::VisitOMPCopyinClause(OMPCopyinClause *C) {
12273 C->setLParenLoc(Record.readSourceLocation());
12274 unsigned NumVars = C->varlist_size();
12275 SmallVector<Expr *, 16> Exprs;
12276 Exprs.reserve(NumVars);
12277 for (unsigned i = 0; i != NumVars; ++i)
12278 Exprs.push_back(Record.readSubExpr());
12279 C->setVarRefs(Exprs);
12280 Exprs.clear();
12281 for (unsigned i = 0; i != NumVars; ++i)
12282 Exprs.push_back(Record.readSubExpr());
12283 C->setSourceExprs(Exprs);
12284 Exprs.clear();
12285 for (unsigned i = 0; i != NumVars; ++i)
12286 Exprs.push_back(Record.readSubExpr());
12287 C->setDestinationExprs(Exprs);
12288 Exprs.clear();
12289 for (unsigned i = 0; i != NumVars; ++i)
12290 Exprs.push_back(Record.readSubExpr());
12291 C->setAssignmentOps(Exprs);
12292}
12293
12294void OMPClauseReader::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
12295 C->setLParenLoc(Record.readSourceLocation());
12296 unsigned NumVars = C->varlist_size();
12297 SmallVector<Expr *, 16> Exprs;
12298 Exprs.reserve(NumVars);
12299 for (unsigned i = 0; i != NumVars; ++i)
12300 Exprs.push_back(Record.readSubExpr());
12301 C->setVarRefs(Exprs);
12302 Exprs.clear();
12303 for (unsigned i = 0; i != NumVars; ++i)
12304 Exprs.push_back(Record.readSubExpr());
12305 C->setSourceExprs(Exprs);
12306 Exprs.clear();
12307 for (unsigned i = 0; i != NumVars; ++i)
12308 Exprs.push_back(Record.readSubExpr());
12309 C->setDestinationExprs(Exprs);
12310 Exprs.clear();
12311 for (unsigned i = 0; i != NumVars; ++i)
12312 Exprs.push_back(Record.readSubExpr());
12313 C->setAssignmentOps(Exprs);
12314}
12315
12316void OMPClauseReader::VisitOMPFlushClause(OMPFlushClause *C) {
12317 C->setLParenLoc(Record.readSourceLocation());
12318 unsigned NumVars = C->varlist_size();
12319 SmallVector<Expr *, 16> Vars;
12320 Vars.reserve(NumVars);
12321 for (unsigned i = 0; i != NumVars; ++i)
12322 Vars.push_back(Record.readSubExpr());
12323 C->setVarRefs(Vars);
12324}
12325
12326void OMPClauseReader::VisitOMPDependClause(OMPDependClause *C) {
12327 C->setLParenLoc(Record.readSourceLocation());
12328 C->setDependencyKind(
12329 static_cast<OpenMPDependClauseKind>(Record.readInt()));
12330 C->setDependencyLoc(Record.readSourceLocation());
12331 C->setColonLoc(Record.readSourceLocation());
12332 unsigned NumVars = C->varlist_size();
12333 SmallVector<Expr *, 16> Vars;
12334 Vars.reserve(NumVars);
12335 for (unsigned I = 0; I != NumVars; ++I)
12336 Vars.push_back(Record.readSubExpr());
12337 C->setVarRefs(Vars);
12338 for (unsigned I = 0, E = C->getNumLoops(); I < E; ++I)
12339 C->setLoopData(I, Record.readSubExpr());
12340}
12341
12342void OMPClauseReader::VisitOMPDeviceClause(OMPDeviceClause *C) {
12343 VisitOMPClauseWithPreInit(C);
12344 C->setDevice(Record.readSubExpr());
12345 C->setLParenLoc(Record.readSourceLocation());
12346}
12347
12348void OMPClauseReader::VisitOMPMapClause(OMPMapClause *C) {
12349 C->setLParenLoc(Record.readSourceLocation());
12350 for (unsigned I = 0; I < OMPMapClause::NumberOfModifiers; ++I) {
12351 C->setMapTypeModifier(
12352 I, static_cast<OpenMPMapModifierKind>(Record.readInt()));
12353 C->setMapTypeModifierLoc(I, Record.readSourceLocation());
12354 }
12355 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12356 DeclarationNameInfo DNI;
12357 Record.readDeclarationNameInfo(DNI);
12358 C->setMapperIdInfo(DNI);
12359 C->setMapType(
12360 static_cast<OpenMPMapClauseKind>(Record.readInt()));
12361 C->setMapLoc(Record.readSourceLocation());
12362 C->setColonLoc(Record.readSourceLocation());
12363 auto NumVars = C->varlist_size();
12364 auto UniqueDecls = C->getUniqueDeclarationsNum();
12365 auto TotalLists = C->getTotalComponentListNum();
12366 auto TotalComponents = C->getTotalComponentsNum();
12367
12368 SmallVector<Expr *, 16> Vars;
12369 Vars.reserve(NumVars);
12370 for (unsigned i = 0; i != NumVars; ++i)
12371 Vars.push_back(Record.readExpr());
12372 C->setVarRefs(Vars);
12373
12374 SmallVector<Expr *, 16> UDMappers;
12375 UDMappers.reserve(NumVars);
12376 for (unsigned I = 0; I < NumVars; ++I)
12377 UDMappers.push_back(Record.readExpr());
12378 C->setUDMapperRefs(UDMappers);
12379
12380 SmallVector<ValueDecl *, 16> Decls;
12381 Decls.reserve(UniqueDecls);
12382 for (unsigned i = 0; i < UniqueDecls; ++i)
12383 Decls.push_back(Record.readDeclAs<ValueDecl>());
12384 C->setUniqueDecls(Decls);
12385
12386 SmallVector<unsigned, 16> ListsPerDecl;
12387 ListsPerDecl.reserve(UniqueDecls);
12388 for (unsigned i = 0; i < UniqueDecls; ++i)
12389 ListsPerDecl.push_back(Record.readInt());
12390 C->setDeclNumLists(ListsPerDecl);
12391
12392 SmallVector<unsigned, 32> ListSizes;
12393 ListSizes.reserve(TotalLists);
12394 for (unsigned i = 0; i < TotalLists; ++i)
12395 ListSizes.push_back(Record.readInt());
12396 C->setComponentListSizes(ListSizes);
12397
12398 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12399 Components.reserve(TotalComponents);
12400 for (unsigned i = 0; i < TotalComponents; ++i) {
12401 Expr *AssociatedExpr = Record.readExpr();
12402 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12403 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12404 AssociatedExpr, AssociatedDecl));
12405 }
12406 C->setComponents(Components, ListSizes);
12407}
12408
12409void OMPClauseReader::VisitOMPAllocateClause(OMPAllocateClause *C) {
12410 C->setLParenLoc(Record.readSourceLocation());
12411 C->setColonLoc(Record.readSourceLocation());
12412 C->setAllocator(Record.readSubExpr());
12413 unsigned NumVars = C->varlist_size();
12414 SmallVector<Expr *, 16> Vars;
12415 Vars.reserve(NumVars);
12416 for (unsigned i = 0; i != NumVars; ++i)
12417 Vars.push_back(Record.readSubExpr());
12418 C->setVarRefs(Vars);
12419}
12420
12421void OMPClauseReader::VisitOMPNumTeamsClause(OMPNumTeamsClause *C) {
12422 VisitOMPClauseWithPreInit(C);
12423 C->setNumTeams(Record.readSubExpr());
12424 C->setLParenLoc(Record.readSourceLocation());
12425}
12426
12427void OMPClauseReader::VisitOMPThreadLimitClause(OMPThreadLimitClause *C) {
12428 VisitOMPClauseWithPreInit(C);
12429 C->setThreadLimit(Record.readSubExpr());
12430 C->setLParenLoc(Record.readSourceLocation());
12431}
12432
12433void OMPClauseReader::VisitOMPPriorityClause(OMPPriorityClause *C) {
12434 C->setPriority(Record.readSubExpr());
12435 C->setLParenLoc(Record.readSourceLocation());
12436}
12437
12438void OMPClauseReader::VisitOMPGrainsizeClause(OMPGrainsizeClause *C) {
12439 C->setGrainsize(Record.readSubExpr());
12440 C->setLParenLoc(Record.readSourceLocation());
12441}
12442
12443void OMPClauseReader::VisitOMPNumTasksClause(OMPNumTasksClause *C) {
12444 C->setNumTasks(Record.readSubExpr());
12445 C->setLParenLoc(Record.readSourceLocation());
12446}
12447
12448void OMPClauseReader::VisitOMPHintClause(OMPHintClause *C) {
12449 C->setHint(Record.readSubExpr());
12450 C->setLParenLoc(Record.readSourceLocation());
12451}
12452
12453void OMPClauseReader::VisitOMPDistScheduleClause(OMPDistScheduleClause *C) {
12454 VisitOMPClauseWithPreInit(C);
12455 C->setDistScheduleKind(
12456 static_cast<OpenMPDistScheduleClauseKind>(Record.readInt()));
12457 C->setChunkSize(Record.readSubExpr());
12458 C->setLParenLoc(Record.readSourceLocation());
12459 C->setDistScheduleKindLoc(Record.readSourceLocation());
12460 C->setCommaLoc(Record.readSourceLocation());
12461}
12462
12463void OMPClauseReader::VisitOMPDefaultmapClause(OMPDefaultmapClause *C) {
12464 C->setDefaultmapKind(
12465 static_cast<OpenMPDefaultmapClauseKind>(Record.readInt()));
12466 C->setDefaultmapModifier(
12467 static_cast<OpenMPDefaultmapClauseModifier>(Record.readInt()));
12468 C->setLParenLoc(Record.readSourceLocation());
12469 C->setDefaultmapModifierLoc(Record.readSourceLocation());
12470 C->setDefaultmapKindLoc(Record.readSourceLocation());
12471}
12472
12473void OMPClauseReader::VisitOMPToClause(OMPToClause *C) {
12474 C->setLParenLoc(Record.readSourceLocation());
12475 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12476 DeclarationNameInfo DNI;
12477 Record.readDeclarationNameInfo(DNI);
12478 C->setMapperIdInfo(DNI);
12479 auto NumVars = C->varlist_size();
12480 auto UniqueDecls = C->getUniqueDeclarationsNum();
12481 auto TotalLists = C->getTotalComponentListNum();
12482 auto TotalComponents = C->getTotalComponentsNum();
12483
12484 SmallVector<Expr *, 16> Vars;
12485 Vars.reserve(NumVars);
12486 for (unsigned i = 0; i != NumVars; ++i)
12487 Vars.push_back(Record.readSubExpr());
12488 C->setVarRefs(Vars);
12489
12490 SmallVector<Expr *, 16> UDMappers;
12491 UDMappers.reserve(NumVars);
12492 for (unsigned I = 0; I < NumVars; ++I)
12493 UDMappers.push_back(Record.readSubExpr());
12494 C->setUDMapperRefs(UDMappers);
12495
12496 SmallVector<ValueDecl *, 16> Decls;
12497 Decls.reserve(UniqueDecls);
12498 for (unsigned i = 0; i < UniqueDecls; ++i)
12499 Decls.push_back(Record.readDeclAs<ValueDecl>());
12500 C->setUniqueDecls(Decls);
12501
12502 SmallVector<unsigned, 16> ListsPerDecl;
12503 ListsPerDecl.reserve(UniqueDecls);
12504 for (unsigned i = 0; i < UniqueDecls; ++i)
12505 ListsPerDecl.push_back(Record.readInt());
12506 C->setDeclNumLists(ListsPerDecl);
12507
12508 SmallVector<unsigned, 32> ListSizes;
12509 ListSizes.reserve(TotalLists);
12510 for (unsigned i = 0; i < TotalLists; ++i)
12511 ListSizes.push_back(Record.readInt());
12512 C->setComponentListSizes(ListSizes);
12513
12514 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12515 Components.reserve(TotalComponents);
12516 for (unsigned i = 0; i < TotalComponents; ++i) {
12517 Expr *AssociatedExpr = Record.readSubExpr();
12518 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12519 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12520 AssociatedExpr, AssociatedDecl));
12521 }
12522 C->setComponents(Components, ListSizes);
12523}
12524
12525void OMPClauseReader::VisitOMPFromClause(OMPFromClause *C) {
12526 C->setLParenLoc(Record.readSourceLocation());
12527 C->setMapperQualifierLoc(Record.readNestedNameSpecifierLoc());
12528 DeclarationNameInfo DNI;
12529 Record.readDeclarationNameInfo(DNI);
12530 C->setMapperIdInfo(DNI);
12531 auto NumVars = C->varlist_size();
12532 auto UniqueDecls = C->getUniqueDeclarationsNum();
12533 auto TotalLists = C->getTotalComponentListNum();
12534 auto TotalComponents = C->getTotalComponentsNum();
12535
12536 SmallVector<Expr *, 16> Vars;
12537 Vars.reserve(NumVars);
12538 for (unsigned i = 0; i != NumVars; ++i)
12539 Vars.push_back(Record.readSubExpr());
12540 C->setVarRefs(Vars);
12541
12542 SmallVector<Expr *, 16> UDMappers;
12543 UDMappers.reserve(NumVars);
12544 for (unsigned I = 0; I < NumVars; ++I)
12545 UDMappers.push_back(Record.readSubExpr());
12546 C->setUDMapperRefs(UDMappers);
12547
12548 SmallVector<ValueDecl *, 16> Decls;
12549 Decls.reserve(UniqueDecls);
12550 for (unsigned i = 0; i < UniqueDecls; ++i)
12551 Decls.push_back(Record.readDeclAs<ValueDecl>());
12552 C->setUniqueDecls(Decls);
12553
12554 SmallVector<unsigned, 16> ListsPerDecl;
12555 ListsPerDecl.reserve(UniqueDecls);
12556 for (unsigned i = 0; i < UniqueDecls; ++i)
12557 ListsPerDecl.push_back(Record.readInt());
12558 C->setDeclNumLists(ListsPerDecl);
12559
12560 SmallVector<unsigned, 32> ListSizes;
12561 ListSizes.reserve(TotalLists);
12562 for (unsigned i = 0; i < TotalLists; ++i)
12563 ListSizes.push_back(Record.readInt());
12564 C->setComponentListSizes(ListSizes);
12565
12566 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12567 Components.reserve(TotalComponents);
12568 for (unsigned i = 0; i < TotalComponents; ++i) {
12569 Expr *AssociatedExpr = Record.readSubExpr();
12570 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12571 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12572 AssociatedExpr, AssociatedDecl));
12573 }
12574 C->setComponents(Components, ListSizes);
12575}
12576
12577void OMPClauseReader::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *C) {
12578 C->setLParenLoc(Record.readSourceLocation());
12579 auto NumVars = C->varlist_size();
12580 auto UniqueDecls = C->getUniqueDeclarationsNum();
12581 auto TotalLists = C->getTotalComponentListNum();
12582 auto TotalComponents = C->getTotalComponentsNum();
12583
12584 SmallVector<Expr *, 16> Vars;
12585 Vars.reserve(NumVars);
12586 for (unsigned i = 0; i != NumVars; ++i)
12587 Vars.push_back(Record.readSubExpr());
12588 C->setVarRefs(Vars);
12589 Vars.clear();
12590 for (unsigned i = 0; i != NumVars; ++i)
12591 Vars.push_back(Record.readSubExpr());
12592 C->setPrivateCopies(Vars);
12593 Vars.clear();
12594 for (unsigned i = 0; i != NumVars; ++i)
12595 Vars.push_back(Record.readSubExpr());
12596 C->setInits(Vars);
12597
12598 SmallVector<ValueDecl *, 16> Decls;
12599 Decls.reserve(UniqueDecls);
12600 for (unsigned i = 0; i < UniqueDecls; ++i)
12601 Decls.push_back(Record.readDeclAs<ValueDecl>());
12602 C->setUniqueDecls(Decls);
12603
12604 SmallVector<unsigned, 16> ListsPerDecl;
12605 ListsPerDecl.reserve(UniqueDecls);
12606 for (unsigned i = 0; i < UniqueDecls; ++i)
12607 ListsPerDecl.push_back(Record.readInt());
12608 C->setDeclNumLists(ListsPerDecl);
12609
12610 SmallVector<unsigned, 32> ListSizes;
12611 ListSizes.reserve(TotalLists);
12612 for (unsigned i = 0; i < TotalLists; ++i)
12613 ListSizes.push_back(Record.readInt());
12614 C->setComponentListSizes(ListSizes);
12615
12616 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12617 Components.reserve(TotalComponents);
12618 for (unsigned i = 0; i < TotalComponents; ++i) {
12619 Expr *AssociatedExpr = Record.readSubExpr();
12620 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12621 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12622 AssociatedExpr, AssociatedDecl));
12623 }
12624 C->setComponents(Components, ListSizes);
12625}
12626
12627void OMPClauseReader::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *C) {
12628 C->setLParenLoc(Record.readSourceLocation());
12629 auto NumVars = C->varlist_size();
12630 auto UniqueDecls = C->getUniqueDeclarationsNum();
12631 auto TotalLists = C->getTotalComponentListNum();
12632 auto TotalComponents = C->getTotalComponentsNum();
12633
12634 SmallVector<Expr *, 16> Vars;
12635 Vars.reserve(NumVars);
12636 for (unsigned i = 0; i != NumVars; ++i)
12637 Vars.push_back(Record.readSubExpr());
12638 C->setVarRefs(Vars);
12639 Vars.clear();
12640
12641 SmallVector<ValueDecl *, 16> Decls;
12642 Decls.reserve(UniqueDecls);
12643 for (unsigned i = 0; i < UniqueDecls; ++i)
12644 Decls.push_back(Record.readDeclAs<ValueDecl>());
12645 C->setUniqueDecls(Decls);
12646
12647 SmallVector<unsigned, 16> ListsPerDecl;
12648 ListsPerDecl.reserve(UniqueDecls);
12649 for (unsigned i = 0; i < UniqueDecls; ++i)
12650 ListsPerDecl.push_back(Record.readInt());
12651 C->setDeclNumLists(ListsPerDecl);
12652
12653 SmallVector<unsigned, 32> ListSizes;
12654 ListSizes.reserve(TotalLists);
12655 for (unsigned i = 0; i < TotalLists; ++i)
12656 ListSizes.push_back(Record.readInt());
12657 C->setComponentListSizes(ListSizes);
12658
12659 SmallVector<OMPClauseMappableExprCommon::MappableComponent, 32> Components;
12660 Components.reserve(TotalComponents);
12661 for (unsigned i = 0; i < TotalComponents; ++i) {
12662 Expr *AssociatedExpr = Record.readSubExpr();
12663 auto *AssociatedDecl = Record.readDeclAs<ValueDecl>();
12664 Components.push_back(OMPClauseMappableExprCommon::MappableComponent(
12665 AssociatedExpr, AssociatedDecl));
12666 }
12667 C->setComponents(Components, ListSizes);
12668}

/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h

1//===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This header defines the BitstreamReader class. This class can be used to
10// read an arbitrary bitstream, regardless of its contents.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_BITCODE_BITSTREAMREADER_H
15#define LLVM_BITCODE_BITSTREAMREADER_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/Bitcode/BitCodes.h"
20#include "llvm/Support/Endian.h"
21#include "llvm/Support/ErrorHandling.h"
22#include "llvm/Support/MathExtras.h"
23#include "llvm/Support/MemoryBuffer.h"
24#include <algorithm>
25#include <cassert>
26#include <climits>
27#include <cstddef>
28#include <cstdint>
29#include <memory>
30#include <string>
31#include <utility>
32#include <vector>
33
34namespace llvm {
35
36/// This class maintains the abbreviations read from a block info block.
37class BitstreamBlockInfo {
38public:
39 /// This contains information emitted to BLOCKINFO_BLOCK blocks. These
40 /// describe abbreviations that all blocks of the specified ID inherit.
41 struct BlockInfo {
42 unsigned BlockID;
43 std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
44 std::string Name;
45 std::vector<std::pair<unsigned, std::string>> RecordNames;
46 };
47
48private:
49 std::vector<BlockInfo> BlockInfoRecords;
50
51public:
52 /// If there is block info for the specified ID, return it, otherwise return
53 /// null.
54 const BlockInfo *getBlockInfo(unsigned BlockID) const {
55 // Common case, the most recent entry matches BlockID.
56 if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
57 return &BlockInfoRecords.back();
58
59 for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
60 i != e; ++i)
61 if (BlockInfoRecords[i].BlockID == BlockID)
62 return &BlockInfoRecords[i];
63 return nullptr;
64 }
65
66 BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
67 if (const BlockInfo *BI = getBlockInfo(BlockID))
68 return *const_cast<BlockInfo*>(BI);
69
70 // Otherwise, add a new record.
71 BlockInfoRecords.emplace_back();
72 BlockInfoRecords.back().BlockID = BlockID;
73 return BlockInfoRecords.back();
74 }
75};
76
77/// This represents a position within a bitstream. There may be multiple
78/// independent cursors reading within one bitstream, each maintaining their
79/// own local state.
80class SimpleBitstreamCursor {
81 ArrayRef<uint8_t> BitcodeBytes;
82 size_t NextChar = 0;
83
84public:
85 /// This is the current data we have pulled from the stream but have not
86 /// returned to the client. This is specifically and intentionally defined to
87 /// follow the word size of the host machine for efficiency. We use word_t in
88 /// places that are aware of this to make it perfectly explicit what is going
89 /// on.
90 using word_t = size_t;
91
92private:
93 word_t CurWord = 0;
94
95 /// This is the number of bits in CurWord that are valid. This is always from
96 /// [0...bits_of(size_t)-1] inclusive.
97 unsigned BitsInCurWord = 0;
98
99public:
100 static const size_t MaxChunkSize = sizeof(word_t) * 8;
101
102 SimpleBitstreamCursor() = default;
103 explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
104 : BitcodeBytes(BitcodeBytes) {}
105 explicit SimpleBitstreamCursor(StringRef BitcodeBytes)
106 : BitcodeBytes(arrayRefFromStringRef(BitcodeBytes)) {}
107 explicit SimpleBitstreamCursor(MemoryBufferRef BitcodeBytes)
108 : SimpleBitstreamCursor(BitcodeBytes.getBuffer()) {}
109
110 bool canSkipToPos(size_t pos) const {
111 // pos can be skipped to if it is a valid address or one byte past the end.
112 return pos <= BitcodeBytes.size();
113 }
114
115 bool AtEndOfStream() {
116 return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
117 }
118
119 /// Return the bit # of the bit we are reading.
120 uint64_t GetCurrentBitNo() const {
121 return NextChar*CHAR_BIT8 - BitsInCurWord;
122 }
123
124 // Return the byte # of the current bit.
125 uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; }
126
127 ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }
128
129 /// Reset the stream to the specified bit number.
130 void JumpToBit(uint64_t BitNo) {
131 size_t ByteNo = size_t(BitNo/8) & ~(sizeof(word_t)-1);
132 unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
133 assert(canSkipToPos(ByteNo) && "Invalid location")((canSkipToPos(ByteNo) && "Invalid location") ? static_cast
<void> (0) : __assert_fail ("canSkipToPos(ByteNo) && \"Invalid location\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 133, __PRETTY_FUNCTION__))
;
134
135 // Move the cursor to the right word.
136 NextChar = ByteNo;
137 BitsInCurWord = 0;
138
139 // Skip over any bits that are already consumed.
140 if (WordBitNo)
141 Read(WordBitNo);
142 }
143
144 /// Get a pointer into the bitstream at the specified byte offset.
145 const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
146 return BitcodeBytes.data() + ByteNo;
147 }
148
149 /// Get a pointer into the bitstream at the specified bit offset.
150 ///
151 /// The bit offset must be on a byte boundary.
152 const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
153 assert(!(BitNo % 8) && "Expected bit on byte boundary")((!(BitNo % 8) && "Expected bit on byte boundary") ? static_cast
<void> (0) : __assert_fail ("!(BitNo % 8) && \"Expected bit on byte boundary\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 153, __PRETTY_FUNCTION__))
;
154 return getPointerToByte(BitNo / 8, NumBytes);
155 }
156
157 void fillCurWord() {
158 if (NextChar >= BitcodeBytes.size())
159 report_fatal_error("Unexpected end of file");
160
161 // Read the next word from the stream.
162 const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar;
163 unsigned BytesRead;
164 if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) {
165 BytesRead = sizeof(word_t);
166 CurWord =
167 support::endian::read<word_t, support::little, support::unaligned>(
168 NextCharPtr);
169 } else {
170 // Short read.
171 BytesRead = BitcodeBytes.size() - NextChar;
172 CurWord = 0;
173 for (unsigned B = 0; B != BytesRead; ++B)
174 CurWord |= uint64_t(NextCharPtr[B]) << (B * 8);
175 }
176 NextChar += BytesRead;
177 BitsInCurWord = BytesRead * 8;
178 }
179
180 word_t Read(unsigned NumBits) {
181 static const unsigned BitsInWord = MaxChunkSize;
182
183 assert(NumBits && NumBits <= BitsInWord &&((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 184, __PRETTY_FUNCTION__))
6
Assuming 'NumBits' is not equal to 0
7
Assuming 'NumBits' is <= 'BitsInWord'
8
'?' condition is true
184 "Cannot return zero or more than BitsInWord bits!")((NumBits && NumBits <= BitsInWord && "Cannot return zero or more than BitsInWord bits!"
) ? static_cast<void> (0) : __assert_fail ("NumBits && NumBits <= BitsInWord && \"Cannot return zero or more than BitsInWord bits!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/include/llvm/Bitcode/BitstreamReader.h"
, 184, __PRETTY_FUNCTION__))
;
185
186 static const unsigned Mask = sizeof(word_t) > 4 ? 0x3f : 0x1f;
187
188 // If the field is fully contained by CurWord, return it quickly.
189 if (BitsInCurWord >= NumBits) {
9
Assuming the condition is false
10
Taking false branch
190 word_t R = CurWord & (~word_t(0) >> (BitsInWord - NumBits));
191
192 // Use a mask to avoid undefined behavior.
193 CurWord >>= (NumBits & Mask);
194
195 BitsInCurWord -= NumBits;
196 return R;
197 }
198
199 word_t R = BitsInCurWord ? CurWord : 0;
11
Assuming the condition is true
12
'?' condition is true
200 unsigned BitsLeft = NumBits - BitsInCurWord;
201
202 fillCurWord();
203
204 // If we run out of data, abort.
205 if (BitsLeft > BitsInCurWord)
13
Assuming the condition is false
14
Taking false branch
206 report_fatal_error("Unexpected end of file");
207
208 word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
15
The result of the right shift is undefined due to shifting by '64', which is greater or equal to the width of type 'llvm::SimpleBitstreamCursor::word_t'
209
210 // Use a mask to avoid undefined behavior.
211 CurWord >>= (BitsLeft & Mask);
212
213 BitsInCurWord -= BitsLeft;
214
215 R |= R2 << (NumBits - BitsLeft);
216
217 return R;
218 }
219
220 uint32_t ReadVBR(unsigned NumBits) {
221 uint32_t Piece = Read(NumBits);
222 if ((Piece & (1U << (NumBits-1))) == 0)
223 return Piece;
224
225 uint32_t Result = 0;
226 unsigned NextBit = 0;
227 while (true) {
228 Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;
229
230 if ((Piece & (1U << (NumBits-1))) == 0)
231 return Result;
232
233 NextBit += NumBits-1;
234 Piece = Read(NumBits);
235 }
236 }
237
238 // Read a VBR that may have a value up to 64-bits in size. The chunk size of
239 // the VBR must still be <= 32 bits though.
240 uint64_t ReadVBR64(unsigned NumBits) {
241 uint32_t Piece = Read(NumBits);
242 if ((Piece & (1U << (NumBits-1))) == 0)
243 return uint64_t(Piece);
244
245 uint64_t Result = 0;
246 unsigned NextBit = 0;
247 while (true) {
248 Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;
249
250 if ((Piece & (1U << (NumBits-1))) == 0)
251 return Result;
252
253 NextBit += NumBits-1;
254 Piece = Read(NumBits);
255 }
256 }
257
258 void SkipToFourByteBoundary() {
259 // If word_t is 64-bits and if we've read less than 32 bits, just dump
260 // the bits we have up to the next 32-bit boundary.
261 if (sizeof(word_t) > 4 &&
262 BitsInCurWord >= 32) {
263 CurWord >>= BitsInCurWord-32;
264 BitsInCurWord = 32;
265 return;
266 }
267
268 BitsInCurWord = 0;
269 }
270
271 /// Skip to the end of the file.
272 void skipToEnd() { NextChar = BitcodeBytes.size(); }
273};
274
275/// When advancing through a bitstream cursor, each advance can discover a few
276/// different kinds of entries:
277struct BitstreamEntry {
278 enum {
279 Error, // Malformed bitcode was found.
280 EndBlock, // We've reached the end of the current block, (or the end of the
281 // file, which is treated like a series of EndBlock records.
282 SubBlock, // This is the start of a new subblock of a specific ID.
283 Record // This is a record with a specific AbbrevID.
284 } Kind;
285
286 unsigned ID;
287
288 static BitstreamEntry getError() {
289 BitstreamEntry E; E.Kind = Error; return E;
290 }
291
292 static BitstreamEntry getEndBlock() {
293 BitstreamEntry E; E.Kind = EndBlock; return E;
294 }
295
296 static BitstreamEntry getSubBlock(unsigned ID) {
297 BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
298 }
299
300 static BitstreamEntry getRecord(unsigned AbbrevID) {
301 BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
302 }
303};
304
305/// This represents a position within a bitcode file, implemented on top of a
306/// SimpleBitstreamCursor.
307///
308/// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
309/// be passed by value.
310class BitstreamCursor : SimpleBitstreamCursor {
311 // This is the declared size of code values used for the current block, in
312 // bits.
313 unsigned CurCodeSize = 2;
314
315 /// Abbrevs installed at in this block.
316 std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
317
318 struct Block {
319 unsigned PrevCodeSize;
320 std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;
321
322 explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
323 };
324
325 /// This tracks the codesize of parent blocks.
326 SmallVector<Block, 8> BlockScope;
327
328 BitstreamBlockInfo *BlockInfo = nullptr;
329
330public:
331 static const size_t MaxChunkSize = sizeof(word_t) * 8;
332
333 BitstreamCursor() = default;
334 explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
335 : SimpleBitstreamCursor(BitcodeBytes) {}
336 explicit BitstreamCursor(StringRef BitcodeBytes)
337 : SimpleBitstreamCursor(BitcodeBytes) {}
338 explicit BitstreamCursor(MemoryBufferRef BitcodeBytes)
339 : SimpleBitstreamCursor(BitcodeBytes) {}
340
341 using SimpleBitstreamCursor::canSkipToPos;
342 using SimpleBitstreamCursor::AtEndOfStream;
343 using SimpleBitstreamCursor::getBitcodeBytes;
344 using SimpleBitstreamCursor::GetCurrentBitNo;
345 using SimpleBitstreamCursor::getCurrentByteNo;
346 using SimpleBitstreamCursor::getPointerToByte;
347 using SimpleBitstreamCursor::JumpToBit;
348 using SimpleBitstreamCursor::fillCurWord;
349 using SimpleBitstreamCursor::Read;
350 using SimpleBitstreamCursor::ReadVBR;
351 using SimpleBitstreamCursor::ReadVBR64;
352
353 /// Return the number of bits used to encode an abbrev #.
354 unsigned getAbbrevIDWidth() const { return CurCodeSize; }
355
356 /// Flags that modify the behavior of advance().
357 enum {
358 /// If this flag is used, the advance() method does not automatically pop
359 /// the block scope when the end of a block is reached.
360 AF_DontPopBlockAtEnd = 1,
361
362 /// If this flag is used, abbrev entries are returned just like normal
363 /// records.
364 AF_DontAutoprocessAbbrevs = 2
365 };
366
367 /// Advance the current bitstream, returning the next entry in the stream.
368 BitstreamEntry advance(unsigned Flags = 0) {
369 while (true) {
370 if (AtEndOfStream())
371 return BitstreamEntry::getError();
372
373 unsigned Code = ReadCode();
374 if (Code == bitc::END_BLOCK) {
375 // Pop the end of the block unless Flags tells us not to.
376 if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
377 return BitstreamEntry::getError();
378 return BitstreamEntry::getEndBlock();
379 }
380
381 if (Code == bitc::ENTER_SUBBLOCK)
382 return BitstreamEntry::getSubBlock(ReadSubBlockID());
383
384 if (Code == bitc::DEFINE_ABBREV &&
385 !(Flags & AF_DontAutoprocessAbbrevs)) {
386 // We read and accumulate abbrev's, the client can't do anything with
387 // them anyway.
388 ReadAbbrevRecord();
389 continue;
390 }
391
392 return BitstreamEntry::getRecord(Code);
393 }
394 }
395
396 /// This is a convenience function for clients that don't expect any
397 /// subblocks. This just skips over them automatically.
398 BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
399 while (true) {
400 // If we found a normal entry, return it.
401 BitstreamEntry Entry = advance(Flags);
402 if (Entry.Kind != BitstreamEntry::SubBlock)
403 return Entry;
404
405 // If we found a sub-block, just skip over it and check the next entry.
406 if (SkipBlock())
407 return BitstreamEntry::getError();
408 }
409 }
410
411 unsigned ReadCode() {
412 return Read(CurCodeSize);
5
Calling 'SimpleBitstreamCursor::Read'
413 }
414
415 // Block header:
416 // [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
417
418 /// Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
419 unsigned ReadSubBlockID() {
420 return ReadVBR(bitc::BlockIDWidth);
421 }
422
423 /// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body
424 /// of this block. If the block record is malformed, return true.
425 bool SkipBlock() {
426 // Read and ignore the codelen value. Since we are skipping this block, we
427 // don't care what code widths are used inside of it.
428 ReadVBR(bitc::CodeLenWidth);
429 SkipToFourByteBoundary();
430 size_t NumFourBytes = Read(bitc::BlockSizeWidth);
431
432 // Check that the block wasn't partially defined, and that the offset isn't
433 // bogus.
434 size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
435 if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
436 return true;
437
438 JumpToBit(SkipTo);
439 return false;
440 }
441
442 /// Having read the ENTER_SUBBLOCK abbrevid, enter the block, and return true
443 /// if the block has an error.
444 bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = nullptr);
445
446 bool ReadBlockEnd() {
447 if (BlockScope.empty()) return true;
448
449 // Block tail:
450 // [END_BLOCK, <align4bytes>]
451 SkipToFourByteBoundary();
452
453 popBlockScope();
454 return false;
455 }
456
457private:
458 void popBlockScope() {
459 CurCodeSize = BlockScope.back().PrevCodeSize;
460
461 CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs);
462 BlockScope.pop_back();
463 }
464
465 //===--------------------------------------------------------------------===//
466 // Record Processing
467 //===--------------------------------------------------------------------===//
468
469public:
470 /// Return the abbreviation for the specified AbbrevId.
471 const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
472 unsigned AbbrevNo = AbbrevID - bitc::FIRST_APPLICATION_ABBREV;
473 if (AbbrevNo >= CurAbbrevs.size())
474 report_fatal_error("Invalid abbrev number");
475 return CurAbbrevs[AbbrevNo].get();
476 }
477
478 /// Read the current record and discard it, returning the code for the record.
479 unsigned skipRecord(unsigned AbbrevID);
480
481 unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
482 StringRef *Blob = nullptr);
483
484 //===--------------------------------------------------------------------===//
485 // Abbrev Processing
486 //===--------------------------------------------------------------------===//
487 void ReadAbbrevRecord();
488
489 /// Read and return a block info block from the bitstream. If an error was
490 /// encountered, return None.
491 ///
492 /// \param ReadBlockInfoNames Whether to read block/record name information in
493 /// the BlockInfo block. Only llvm-bcanalyzer uses this.
494 Optional<BitstreamBlockInfo>
495 ReadBlockInfoBlock(bool ReadBlockInfoNames = false);
496
497 /// Set the block info to be used by this BitstreamCursor to interpret
498 /// abbreviated records.
499 void setBlockInfo(BitstreamBlockInfo *BI) { BlockInfo = BI; }
500};
501
502} // end llvm namespace
503
504#endif // LLVM_BITCODE_BITSTREAMREADER_H