1 //===-- ASTReader.cpp - AST File Reader ----------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the ASTReader class, which reads AST files.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Serialization/ASTReader.h"
15 #include "ASTCommon.h"
16 #include "ASTReaderInternals.h"
17 #include "clang/AST/ASTConsumer.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Expr.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/Frontend/PCHContainerOperations.h"
23 #include "clang/AST/ASTMutationListener.h"
24 #include "clang/AST/NestedNameSpecifier.h"
25 #include "clang/AST/Type.h"
26 #include "clang/AST/TypeLocVisitor.h"
27 #include "clang/Basic/DiagnosticOptions.h"
28 #include "clang/Basic/FileManager.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/SourceManagerInternals.h"
31 #include "clang/Basic/TargetInfo.h"
32 #include "clang/Basic/TargetOptions.h"
33 #include "clang/Basic/Version.h"
34 #include "clang/Basic/VersionTuple.h"
35 #include "clang/Frontend/Utils.h"
36 #include "clang/Lex/HeaderSearch.h"
37 #include "clang/Lex/HeaderSearchOptions.h"
38 #include "clang/Lex/MacroInfo.h"
39 #include "clang/Lex/PreprocessingRecord.h"
40 #include "clang/Lex/Preprocessor.h"
41 #include "clang/Lex/PreprocessorOptions.h"
42 #include "clang/Sema/Scope.h"
43 #include "clang/Sema/Sema.h"
44 #include "clang/Serialization/ASTDeserializationListener.h"
45 #include "clang/Serialization/GlobalModuleIndex.h"
46 #include "clang/Serialization/ModuleManager.h"
47 #include "clang/Serialization/SerializationDiagnostic.h"
48 #include "llvm/ADT/Hashing.h"
49 #include "llvm/ADT/StringExtras.h"
50 #include "llvm/Bitcode/BitstreamReader.h"
51 #include "llvm/Support/Compression.h"
52 #include "llvm/Support/ErrorHandling.h"
53 #include "llvm/Support/FileSystem.h"
54 #include "llvm/Support/MemoryBuffer.h"
55 #include "llvm/Support/Path.h"
56 #include "llvm/Support/SaveAndRestore.h"
57 #include "llvm/Support/raw_ostream.h"
58 #include <algorithm>
59 #include <cstdio>
60 #include <iterator>
61 #include <system_error>
62
63 using namespace clang;
64 using namespace clang::serialization;
65 using namespace clang::serialization::reader;
66 using llvm::BitstreamCursor;
67
68
69 //===----------------------------------------------------------------------===//
70 // ChainedASTReaderListener implementation
71 //===----------------------------------------------------------------------===//
72
73 bool
ReadFullVersionInformation(StringRef FullVersion)74 ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
75 return First->ReadFullVersionInformation(FullVersion) ||
76 Second->ReadFullVersionInformation(FullVersion);
77 }
ReadModuleName(StringRef ModuleName)78 void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
79 First->ReadModuleName(ModuleName);
80 Second->ReadModuleName(ModuleName);
81 }
ReadModuleMapFile(StringRef ModuleMapPath)82 void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
83 First->ReadModuleMapFile(ModuleMapPath);
84 Second->ReadModuleMapFile(ModuleMapPath);
85 }
86 bool
ReadLanguageOptions(const LangOptions & LangOpts,bool Complain,bool AllowCompatibleDifferences)87 ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
88 bool Complain,
89 bool AllowCompatibleDifferences) {
90 return First->ReadLanguageOptions(LangOpts, Complain,
91 AllowCompatibleDifferences) ||
92 Second->ReadLanguageOptions(LangOpts, Complain,
93 AllowCompatibleDifferences);
94 }
ReadTargetOptions(const TargetOptions & TargetOpts,bool Complain,bool AllowCompatibleDifferences)95 bool ChainedASTReaderListener::ReadTargetOptions(
96 const TargetOptions &TargetOpts, bool Complain,
97 bool AllowCompatibleDifferences) {
98 return First->ReadTargetOptions(TargetOpts, Complain,
99 AllowCompatibleDifferences) ||
100 Second->ReadTargetOptions(TargetOpts, Complain,
101 AllowCompatibleDifferences);
102 }
ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,bool Complain)103 bool ChainedASTReaderListener::ReadDiagnosticOptions(
104 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
105 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
106 Second->ReadDiagnosticOptions(DiagOpts, Complain);
107 }
108 bool
ReadFileSystemOptions(const FileSystemOptions & FSOpts,bool Complain)109 ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
110 bool Complain) {
111 return First->ReadFileSystemOptions(FSOpts, Complain) ||
112 Second->ReadFileSystemOptions(FSOpts, Complain);
113 }
114
ReadHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,bool Complain)115 bool ChainedASTReaderListener::ReadHeaderSearchOptions(
116 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
117 bool Complain) {
118 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
119 Complain) ||
120 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
121 Complain);
122 }
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)123 bool ChainedASTReaderListener::ReadPreprocessorOptions(
124 const PreprocessorOptions &PPOpts, bool Complain,
125 std::string &SuggestedPredefines) {
126 return First->ReadPreprocessorOptions(PPOpts, Complain,
127 SuggestedPredefines) ||
128 Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
129 }
ReadCounter(const serialization::ModuleFile & M,unsigned Value)130 void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
131 unsigned Value) {
132 First->ReadCounter(M, Value);
133 Second->ReadCounter(M, Value);
134 }
needsInputFileVisitation()135 bool ChainedASTReaderListener::needsInputFileVisitation() {
136 return First->needsInputFileVisitation() ||
137 Second->needsInputFileVisitation();
138 }
needsSystemInputFileVisitation()139 bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
140 return First->needsSystemInputFileVisitation() ||
141 Second->needsSystemInputFileVisitation();
142 }
visitModuleFile(StringRef Filename,ModuleKind Kind)143 void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
144 ModuleKind Kind) {
145 First->visitModuleFile(Filename, Kind);
146 Second->visitModuleFile(Filename, Kind);
147 }
visitInputFile(StringRef Filename,bool isSystem,bool isOverridden,bool isExplicitModule)148 bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
149 bool isSystem,
150 bool isOverridden,
151 bool isExplicitModule) {
152 bool Continue = false;
153 if (First->needsInputFileVisitation() &&
154 (!isSystem || First->needsSystemInputFileVisitation()))
155 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
156 isExplicitModule);
157 if (Second->needsInputFileVisitation() &&
158 (!isSystem || Second->needsSystemInputFileVisitation()))
159 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
160 isExplicitModule);
161 return Continue;
162 }
163
readModuleFileExtension(const ModuleFileExtensionMetadata & Metadata)164 void ChainedASTReaderListener::readModuleFileExtension(
165 const ModuleFileExtensionMetadata &Metadata) {
166 First->readModuleFileExtension(Metadata);
167 Second->readModuleFileExtension(Metadata);
168 }
169
170 //===----------------------------------------------------------------------===//
171 // PCH validator implementation
172 //===----------------------------------------------------------------------===//
173
~ASTReaderListener()174 ASTReaderListener::~ASTReaderListener() {}
175
176 /// \brief Compare the given set of language options against an existing set of
177 /// language options.
178 ///
179 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
180 /// \param AllowCompatibleDifferences If true, differences between compatible
181 /// language options will be permitted.
182 ///
183 /// \returns true if the languagae options mis-match, false otherwise.
checkLanguageOptions(const LangOptions & LangOpts,const LangOptions & ExistingLangOpts,DiagnosticsEngine * Diags,bool AllowCompatibleDifferences=true)184 static bool checkLanguageOptions(const LangOptions &LangOpts,
185 const LangOptions &ExistingLangOpts,
186 DiagnosticsEngine *Diags,
187 bool AllowCompatibleDifferences = true) {
188 #define LANGOPT(Name, Bits, Default, Description) \
189 if (ExistingLangOpts.Name != LangOpts.Name) { \
190 if (Diags) \
191 Diags->Report(diag::err_pch_langopt_mismatch) \
192 << Description << LangOpts.Name << ExistingLangOpts.Name; \
193 return true; \
194 }
195
196 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
197 if (ExistingLangOpts.Name != LangOpts.Name) { \
198 if (Diags) \
199 Diags->Report(diag::err_pch_langopt_value_mismatch) \
200 << Description; \
201 return true; \
202 }
203
204 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
205 if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
206 if (Diags) \
207 Diags->Report(diag::err_pch_langopt_value_mismatch) \
208 << Description; \
209 return true; \
210 }
211
212 #define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
213 if (!AllowCompatibleDifferences) \
214 LANGOPT(Name, Bits, Default, Description)
215
216 #define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
217 if (!AllowCompatibleDifferences) \
218 ENUM_LANGOPT(Name, Bits, Default, Description)
219
220 #define COMPATIBLE_VALUE_LANGOPT(Name, Bits, Default, Description) \
221 if (!AllowCompatibleDifferences) \
222 VALUE_LANGOPT(Name, Bits, Default, Description)
223
224 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
225 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
226 #define BENIGN_VALUE_LANGOPT(Name, Type, Bits, Default, Description)
227 #include "clang/Basic/LangOptions.def"
228
229 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
230 if (Diags)
231 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
232 return true;
233 }
234
235 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
236 if (Diags)
237 Diags->Report(diag::err_pch_langopt_value_mismatch)
238 << "target Objective-C runtime";
239 return true;
240 }
241
242 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
243 LangOpts.CommentOpts.BlockCommandNames) {
244 if (Diags)
245 Diags->Report(diag::err_pch_langopt_value_mismatch)
246 << "block command names";
247 return true;
248 }
249
250 return false;
251 }
252
253 /// \brief Compare the given set of target options against an existing set of
254 /// target options.
255 ///
256 /// \param Diags If non-NULL, diagnostics will be emitted via this engine.
257 ///
258 /// \returns true if the target options mis-match, false otherwise.
checkTargetOptions(const TargetOptions & TargetOpts,const TargetOptions & ExistingTargetOpts,DiagnosticsEngine * Diags,bool AllowCompatibleDifferences=true)259 static bool checkTargetOptions(const TargetOptions &TargetOpts,
260 const TargetOptions &ExistingTargetOpts,
261 DiagnosticsEngine *Diags,
262 bool AllowCompatibleDifferences = true) {
263 #define CHECK_TARGET_OPT(Field, Name) \
264 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
265 if (Diags) \
266 Diags->Report(diag::err_pch_targetopt_mismatch) \
267 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
268 return true; \
269 }
270
271 // The triple and ABI must match exactly.
272 CHECK_TARGET_OPT(Triple, "target");
273 CHECK_TARGET_OPT(ABI, "target ABI");
274
275 // We can tolerate different CPUs in many cases, notably when one CPU
276 // supports a strict superset of another. When allowing compatible
277 // differences skip this check.
278 if (!AllowCompatibleDifferences)
279 CHECK_TARGET_OPT(CPU, "target CPU");
280
281 #undef CHECK_TARGET_OPT
282
283 // Compare feature sets.
284 SmallVector<StringRef, 4> ExistingFeatures(
285 ExistingTargetOpts.FeaturesAsWritten.begin(),
286 ExistingTargetOpts.FeaturesAsWritten.end());
287 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
288 TargetOpts.FeaturesAsWritten.end());
289 std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
290 std::sort(ReadFeatures.begin(), ReadFeatures.end());
291
292 // We compute the set difference in both directions explicitly so that we can
293 // diagnose the differences differently.
294 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
295 std::set_difference(
296 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
297 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
298 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
299 ExistingFeatures.begin(), ExistingFeatures.end(),
300 std::back_inserter(UnmatchedReadFeatures));
301
302 // If we are allowing compatible differences and the read feature set is
303 // a strict subset of the existing feature set, there is nothing to diagnose.
304 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
305 return false;
306
307 if (Diags) {
308 for (StringRef Feature : UnmatchedReadFeatures)
309 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
310 << /* is-existing-feature */ false << Feature;
311 for (StringRef Feature : UnmatchedExistingFeatures)
312 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
313 << /* is-existing-feature */ true << Feature;
314 }
315
316 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
317 }
318
319 bool
ReadLanguageOptions(const LangOptions & LangOpts,bool Complain,bool AllowCompatibleDifferences)320 PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
321 bool Complain,
322 bool AllowCompatibleDifferences) {
323 const LangOptions &ExistingLangOpts = PP.getLangOpts();
324 return checkLanguageOptions(LangOpts, ExistingLangOpts,
325 Complain ? &Reader.Diags : nullptr,
326 AllowCompatibleDifferences);
327 }
328
ReadTargetOptions(const TargetOptions & TargetOpts,bool Complain,bool AllowCompatibleDifferences)329 bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
330 bool Complain,
331 bool AllowCompatibleDifferences) {
332 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
333 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
334 Complain ? &Reader.Diags : nullptr,
335 AllowCompatibleDifferences);
336 }
337
338 namespace {
339 typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
340 MacroDefinitionsMap;
341 typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
342 DeclsMap;
343 }
344
checkDiagnosticGroupMappings(DiagnosticsEngine & StoredDiags,DiagnosticsEngine & Diags,bool Complain)345 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
346 DiagnosticsEngine &Diags,
347 bool Complain) {
348 typedef DiagnosticsEngine::Level Level;
349
350 // Check current mappings for new -Werror mappings, and the stored mappings
351 // for cases that were explicitly mapped to *not* be errors that are now
352 // errors because of options like -Werror.
353 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
354
355 for (DiagnosticsEngine *MappingSource : MappingSources) {
356 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
357 diag::kind DiagID = DiagIDMappingPair.first;
358 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
359 if (CurLevel < DiagnosticsEngine::Error)
360 continue; // not significant
361 Level StoredLevel =
362 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
363 if (StoredLevel < DiagnosticsEngine::Error) {
364 if (Complain)
365 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
366 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
367 return true;
368 }
369 }
370 }
371
372 return false;
373 }
374
isExtHandlingFromDiagsError(DiagnosticsEngine & Diags)375 static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
376 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
377 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
378 return true;
379 return Ext >= diag::Severity::Error;
380 }
381
checkDiagnosticMappings(DiagnosticsEngine & StoredDiags,DiagnosticsEngine & Diags,bool IsSystem,bool Complain)382 static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
383 DiagnosticsEngine &Diags,
384 bool IsSystem, bool Complain) {
385 // Top-level options
386 if (IsSystem) {
387 if (Diags.getSuppressSystemWarnings())
388 return false;
389 // If -Wsystem-headers was not enabled before, be conservative
390 if (StoredDiags.getSuppressSystemWarnings()) {
391 if (Complain)
392 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
393 return true;
394 }
395 }
396
397 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
398 if (Complain)
399 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
400 return true;
401 }
402
403 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
404 !StoredDiags.getEnableAllWarnings()) {
405 if (Complain)
406 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
407 return true;
408 }
409
410 if (isExtHandlingFromDiagsError(Diags) &&
411 !isExtHandlingFromDiagsError(StoredDiags)) {
412 if (Complain)
413 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
414 return true;
415 }
416
417 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
418 }
419
ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,bool Complain)420 bool PCHValidator::ReadDiagnosticOptions(
421 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
422 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
423 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
424 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
425 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
426 // This should never fail, because we would have processed these options
427 // before writing them to an ASTFile.
428 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
429
430 ModuleManager &ModuleMgr = Reader.getModuleManager();
431 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
432
433 // If the original import came from a file explicitly generated by the user,
434 // don't check the diagnostic mappings.
435 // FIXME: currently this is approximated by checking whether this is not a
436 // module import of an implicitly-loaded module file.
437 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
438 // the transitive closure of its imports, since unrelated modules cannot be
439 // imported until after this module finishes validation.
440 ModuleFile *TopImport = *ModuleMgr.rbegin();
441 while (!TopImport->ImportedBy.empty())
442 TopImport = TopImport->ImportedBy[0];
443 if (TopImport->Kind != MK_ImplicitModule)
444 return false;
445
446 StringRef ModuleName = TopImport->ModuleName;
447 assert(!ModuleName.empty() && "diagnostic options read before module name");
448
449 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
450 assert(M && "missing module");
451
452 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
453 // contains the union of their flags.
454 return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain);
455 }
456
457 /// \brief Collect the macro definitions provided by the given preprocessor
458 /// options.
459 static void
collectMacroDefinitions(const PreprocessorOptions & PPOpts,MacroDefinitionsMap & Macros,SmallVectorImpl<StringRef> * MacroNames=nullptr)460 collectMacroDefinitions(const PreprocessorOptions &PPOpts,
461 MacroDefinitionsMap &Macros,
462 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
463 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
464 StringRef Macro = PPOpts.Macros[I].first;
465 bool IsUndef = PPOpts.Macros[I].second;
466
467 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
468 StringRef MacroName = MacroPair.first;
469 StringRef MacroBody = MacroPair.second;
470
471 // For an #undef'd macro, we only care about the name.
472 if (IsUndef) {
473 if (MacroNames && !Macros.count(MacroName))
474 MacroNames->push_back(MacroName);
475
476 Macros[MacroName] = std::make_pair("", true);
477 continue;
478 }
479
480 // For a #define'd macro, figure out the actual definition.
481 if (MacroName.size() == Macro.size())
482 MacroBody = "1";
483 else {
484 // Note: GCC drops anything following an end-of-line character.
485 StringRef::size_type End = MacroBody.find_first_of("\n\r");
486 MacroBody = MacroBody.substr(0, End);
487 }
488
489 if (MacroNames && !Macros.count(MacroName))
490 MacroNames->push_back(MacroName);
491 Macros[MacroName] = std::make_pair(MacroBody, false);
492 }
493 }
494
495 /// \brief Check the preprocessor options deserialized from the control block
496 /// against the preprocessor options in an existing preprocessor.
497 ///
498 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
checkPreprocessorOptions(const PreprocessorOptions & PPOpts,const PreprocessorOptions & ExistingPPOpts,DiagnosticsEngine * Diags,FileManager & FileMgr,std::string & SuggestedPredefines,const LangOptions & LangOpts)499 static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
500 const PreprocessorOptions &ExistingPPOpts,
501 DiagnosticsEngine *Diags,
502 FileManager &FileMgr,
503 std::string &SuggestedPredefines,
504 const LangOptions &LangOpts) {
505 // Check macro definitions.
506 MacroDefinitionsMap ASTFileMacros;
507 collectMacroDefinitions(PPOpts, ASTFileMacros);
508 MacroDefinitionsMap ExistingMacros;
509 SmallVector<StringRef, 4> ExistingMacroNames;
510 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
511
512 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
513 // Dig out the macro definition in the existing preprocessor options.
514 StringRef MacroName = ExistingMacroNames[I];
515 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
516
517 // Check whether we know anything about this macro name or not.
518 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
519 = ASTFileMacros.find(MacroName);
520 if (Known == ASTFileMacros.end()) {
521 // FIXME: Check whether this identifier was referenced anywhere in the
522 // AST file. If so, we should reject the AST file. Unfortunately, this
523 // information isn't in the control block. What shall we do about it?
524
525 if (Existing.second) {
526 SuggestedPredefines += "#undef ";
527 SuggestedPredefines += MacroName.str();
528 SuggestedPredefines += '\n';
529 } else {
530 SuggestedPredefines += "#define ";
531 SuggestedPredefines += MacroName.str();
532 SuggestedPredefines += ' ';
533 SuggestedPredefines += Existing.first.str();
534 SuggestedPredefines += '\n';
535 }
536 continue;
537 }
538
539 // If the macro was defined in one but undef'd in the other, we have a
540 // conflict.
541 if (Existing.second != Known->second.second) {
542 if (Diags) {
543 Diags->Report(diag::err_pch_macro_def_undef)
544 << MacroName << Known->second.second;
545 }
546 return true;
547 }
548
549 // If the macro was #undef'd in both, or if the macro bodies are identical,
550 // it's fine.
551 if (Existing.second || Existing.first == Known->second.first)
552 continue;
553
554 // The macro bodies differ; complain.
555 if (Diags) {
556 Diags->Report(diag::err_pch_macro_def_conflict)
557 << MacroName << Known->second.first << Existing.first;
558 }
559 return true;
560 }
561
562 // Check whether we're using predefines.
563 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) {
564 if (Diags) {
565 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
566 }
567 return true;
568 }
569
570 // Detailed record is important since it is used for the module cache hash.
571 if (LangOpts.Modules &&
572 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) {
573 if (Diags) {
574 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
575 }
576 return true;
577 }
578
579 // Compute the #include and #include_macros lines we need.
580 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
581 StringRef File = ExistingPPOpts.Includes[I];
582 if (File == ExistingPPOpts.ImplicitPCHInclude)
583 continue;
584
585 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
586 != PPOpts.Includes.end())
587 continue;
588
589 SuggestedPredefines += "#include \"";
590 SuggestedPredefines += File;
591 SuggestedPredefines += "\"\n";
592 }
593
594 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
595 StringRef File = ExistingPPOpts.MacroIncludes[I];
596 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
597 File)
598 != PPOpts.MacroIncludes.end())
599 continue;
600
601 SuggestedPredefines += "#__include_macros \"";
602 SuggestedPredefines += File;
603 SuggestedPredefines += "\"\n##\n";
604 }
605
606 return false;
607 }
608
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)609 bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
610 bool Complain,
611 std::string &SuggestedPredefines) {
612 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
613
614 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
615 Complain? &Reader.Diags : nullptr,
616 PP.getFileManager(),
617 SuggestedPredefines,
618 PP.getLangOpts());
619 }
620
621 /// Check the header search options deserialized from the control block
622 /// against the header search options in an existing preprocessor.
623 ///
624 /// \param Diags If non-null, produce diagnostics for any mismatches incurred.
checkHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,StringRef ExistingModuleCachePath,DiagnosticsEngine * Diags,const LangOptions & LangOpts)625 static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
626 StringRef SpecificModuleCachePath,
627 StringRef ExistingModuleCachePath,
628 DiagnosticsEngine *Diags,
629 const LangOptions &LangOpts) {
630 if (LangOpts.Modules) {
631 if (SpecificModuleCachePath != ExistingModuleCachePath) {
632 if (Diags)
633 Diags->Report(diag::err_pch_modulecache_mismatch)
634 << SpecificModuleCachePath << ExistingModuleCachePath;
635 return true;
636 }
637 }
638
639 return false;
640 }
641
ReadHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,bool Complain)642 bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
643 StringRef SpecificModuleCachePath,
644 bool Complain) {
645 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
646 PP.getHeaderSearchInfo().getModuleCachePath(),
647 Complain ? &Reader.Diags : nullptr,
648 PP.getLangOpts());
649 }
650
ReadCounter(const ModuleFile & M,unsigned Value)651 void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
652 PP.setCounterValue(Value);
653 }
654
655 //===----------------------------------------------------------------------===//
656 // AST reader implementation
657 //===----------------------------------------------------------------------===//
658
setDeserializationListener(ASTDeserializationListener * Listener,bool TakeOwnership)659 void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
660 bool TakeOwnership) {
661 DeserializationListener = Listener;
662 OwnsDeserializationListener = TakeOwnership;
663 }
664
665
666
ComputeHash(Selector Sel)667 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
668 return serialization::ComputeHash(Sel);
669 }
670
671
672 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)673 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
674 using namespace llvm::support;
675 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
676 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
677 return std::make_pair(KeyLen, DataLen);
678 }
679
680 ASTSelectorLookupTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)681 ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
682 using namespace llvm::support;
683 SelectorTable &SelTable = Reader.getContext().Selectors;
684 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
685 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
686 F, endian::readNext<uint32_t, little, unaligned>(d));
687 if (N == 0)
688 return SelTable.getNullarySelector(FirstII);
689 else if (N == 1)
690 return SelTable.getUnarySelector(FirstII);
691
692 SmallVector<IdentifierInfo *, 16> Args;
693 Args.push_back(FirstII);
694 for (unsigned I = 1; I != N; ++I)
695 Args.push_back(Reader.getLocalIdentifier(
696 F, endian::readNext<uint32_t, little, unaligned>(d)));
697
698 return SelTable.getSelector(N, Args.data());
699 }
700
701 ASTSelectorLookupTrait::data_type
ReadData(Selector,const unsigned char * d,unsigned DataLen)702 ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
703 unsigned DataLen) {
704 using namespace llvm::support;
705
706 data_type Result;
707
708 Result.ID = Reader.getGlobalSelectorID(
709 F, endian::readNext<uint32_t, little, unaligned>(d));
710 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
711 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
712 Result.InstanceBits = FullInstanceBits & 0x3;
713 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
714 Result.FactoryBits = FullFactoryBits & 0x3;
715 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
716 unsigned NumInstanceMethods = FullInstanceBits >> 3;
717 unsigned NumFactoryMethods = FullFactoryBits >> 3;
718
719 // Load instance methods
720 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
721 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
722 F, endian::readNext<uint32_t, little, unaligned>(d)))
723 Result.Instance.push_back(Method);
724 }
725
726 // Load factory methods
727 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
728 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
729 F, endian::readNext<uint32_t, little, unaligned>(d)))
730 Result.Factory.push_back(Method);
731 }
732
733 return Result;
734 }
735
ComputeHash(const internal_key_type & a)736 unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
737 return llvm::HashString(a);
738 }
739
740 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)741 ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
742 using namespace llvm::support;
743 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
744 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
745 return std::make_pair(KeyLen, DataLen);
746 }
747
748 ASTIdentifierLookupTraitBase::internal_key_type
ReadKey(const unsigned char * d,unsigned n)749 ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
750 assert(n >= 2 && d[n-1] == '\0');
751 return StringRef((const char*) d, n-1);
752 }
753
754 /// \brief Whether the given identifier is "interesting".
isInterestingIdentifier(ASTReader & Reader,IdentifierInfo & II,bool IsModule)755 static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
756 bool IsModule) {
757 return II.hadMacroDefinition() ||
758 II.isPoisoned() ||
759 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
760 II.hasRevertedTokenIDToIdentifier() ||
761 (!(IsModule && Reader.getContext().getLangOpts().CPlusPlus) &&
762 II.getFETokenInfo<void>());
763 }
764
readBit(unsigned & Bits)765 static bool readBit(unsigned &Bits) {
766 bool Value = Bits & 0x1;
767 Bits >>= 1;
768 return Value;
769 }
770
ReadIdentifierID(const unsigned char * d)771 IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
772 using namespace llvm::support;
773 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
774 return Reader.getGlobalIdentifierID(F, RawID >> 1);
775 }
776
markIdentifierFromAST(ASTReader & Reader,IdentifierInfo & II)777 static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
778 if (!II.isFromAST()) {
779 II.setIsFromAST();
780 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
781 if (isInterestingIdentifier(Reader, II, IsModule))
782 II.setChangedSinceDeserialization();
783 }
784 }
785
ReadData(const internal_key_type & k,const unsigned char * d,unsigned DataLen)786 IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
787 const unsigned char* d,
788 unsigned DataLen) {
789 using namespace llvm::support;
790 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
791 bool IsInteresting = RawID & 0x01;
792
793 // Wipe out the "is interesting" bit.
794 RawID = RawID >> 1;
795
796 // Build the IdentifierInfo and link the identifier ID with it.
797 IdentifierInfo *II = KnownII;
798 if (!II) {
799 II = &Reader.getIdentifierTable().getOwn(k);
800 KnownII = II;
801 }
802 markIdentifierFromAST(Reader, *II);
803 Reader.markIdentifierUpToDate(II);
804
805 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
806 if (!IsInteresting) {
807 // For uninteresting identifiers, there's nothing else to do. Just notify
808 // the reader that we've finished loading this identifier.
809 Reader.SetIdentifierInfo(ID, II);
810 return II;
811 }
812
813 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
814 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
815 bool CPlusPlusOperatorKeyword = readBit(Bits);
816 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
817 bool HasRevertedBuiltin = readBit(Bits);
818 bool Poisoned = readBit(Bits);
819 bool ExtensionToken = readBit(Bits);
820 bool HadMacroDefinition = readBit(Bits);
821
822 assert(Bits == 0 && "Extra bits in the identifier?");
823 DataLen -= 8;
824
825 // Set or check the various bits in the IdentifierInfo structure.
826 // Token IDs are read-only.
827 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
828 II->revertTokenIDToIdentifier();
829 if (!F.isModule())
830 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
831 else if (HasRevertedBuiltin && II->getBuiltinID()) {
832 II->revertBuiltin();
833 assert((II->hasRevertedBuiltin() ||
834 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
835 "Incorrect ObjC keyword or builtin ID");
836 }
837 assert(II->isExtensionToken() == ExtensionToken &&
838 "Incorrect extension token flag");
839 (void)ExtensionToken;
840 if (Poisoned)
841 II->setIsPoisoned(true);
842 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
843 "Incorrect C++ operator keyword flag");
844 (void)CPlusPlusOperatorKeyword;
845
846 // If this identifier is a macro, deserialize the macro
847 // definition.
848 if (HadMacroDefinition) {
849 uint32_t MacroDirectivesOffset =
850 endian::readNext<uint32_t, little, unaligned>(d);
851 DataLen -= 4;
852
853 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
854 }
855
856 Reader.SetIdentifierInfo(ID, II);
857
858 // Read all of the declarations visible at global scope with this
859 // name.
860 if (DataLen > 0) {
861 SmallVector<uint32_t, 4> DeclIDs;
862 for (; DataLen > 0; DataLen -= 4)
863 DeclIDs.push_back(Reader.getGlobalDeclID(
864 F, endian::readNext<uint32_t, little, unaligned>(d)));
865 Reader.SetGloballyVisibleDecls(II, DeclIDs);
866 }
867
868 return II;
869 }
870
DeclarationNameKey(DeclarationName Name)871 DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
872 : Kind(Name.getNameKind()) {
873 switch (Kind) {
874 case DeclarationName::Identifier:
875 Data = (uint64_t)Name.getAsIdentifierInfo();
876 break;
877 case DeclarationName::ObjCZeroArgSelector:
878 case DeclarationName::ObjCOneArgSelector:
879 case DeclarationName::ObjCMultiArgSelector:
880 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
881 break;
882 case DeclarationName::CXXOperatorName:
883 Data = Name.getCXXOverloadedOperator();
884 break;
885 case DeclarationName::CXXLiteralOperatorName:
886 Data = (uint64_t)Name.getCXXLiteralIdentifier();
887 break;
888 case DeclarationName::CXXConstructorName:
889 case DeclarationName::CXXDestructorName:
890 case DeclarationName::CXXConversionFunctionName:
891 case DeclarationName::CXXUsingDirective:
892 Data = 0;
893 break;
894 }
895 }
896
getHash() const897 unsigned DeclarationNameKey::getHash() const {
898 llvm::FoldingSetNodeID ID;
899 ID.AddInteger(Kind);
900
901 switch (Kind) {
902 case DeclarationName::Identifier:
903 case DeclarationName::CXXLiteralOperatorName:
904 ID.AddString(((IdentifierInfo*)Data)->getName());
905 break;
906 case DeclarationName::ObjCZeroArgSelector:
907 case DeclarationName::ObjCOneArgSelector:
908 case DeclarationName::ObjCMultiArgSelector:
909 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
910 break;
911 case DeclarationName::CXXOperatorName:
912 ID.AddInteger((OverloadedOperatorKind)Data);
913 break;
914 case DeclarationName::CXXConstructorName:
915 case DeclarationName::CXXDestructorName:
916 case DeclarationName::CXXConversionFunctionName:
917 case DeclarationName::CXXUsingDirective:
918 break;
919 }
920
921 return ID.ComputeHash();
922 }
923
924 ModuleFile *
ReadFileRef(const unsigned char * & d)925 ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
926 using namespace llvm::support;
927 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
928 return Reader.getLocalModuleFile(F, ModuleFileID);
929 }
930
931 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)932 ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
933 using namespace llvm::support;
934 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
935 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
936 return std::make_pair(KeyLen, DataLen);
937 }
938
939 ASTDeclContextNameLookupTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)940 ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
941 using namespace llvm::support;
942
943 auto Kind = (DeclarationName::NameKind)*d++;
944 uint64_t Data;
945 switch (Kind) {
946 case DeclarationName::Identifier:
947 Data = (uint64_t)Reader.getLocalIdentifier(
948 F, endian::readNext<uint32_t, little, unaligned>(d));
949 break;
950 case DeclarationName::ObjCZeroArgSelector:
951 case DeclarationName::ObjCOneArgSelector:
952 case DeclarationName::ObjCMultiArgSelector:
953 Data =
954 (uint64_t)Reader.getLocalSelector(
955 F, endian::readNext<uint32_t, little, unaligned>(
956 d)).getAsOpaquePtr();
957 break;
958 case DeclarationName::CXXOperatorName:
959 Data = *d++; // OverloadedOperatorKind
960 break;
961 case DeclarationName::CXXLiteralOperatorName:
962 Data = (uint64_t)Reader.getLocalIdentifier(
963 F, endian::readNext<uint32_t, little, unaligned>(d));
964 break;
965 case DeclarationName::CXXConstructorName:
966 case DeclarationName::CXXDestructorName:
967 case DeclarationName::CXXConversionFunctionName:
968 case DeclarationName::CXXUsingDirective:
969 Data = 0;
970 break;
971 }
972
973 return DeclarationNameKey(Kind, Data);
974 }
975
ReadDataInto(internal_key_type,const unsigned char * d,unsigned DataLen,data_type_builder & Val)976 void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
977 const unsigned char *d,
978 unsigned DataLen,
979 data_type_builder &Val) {
980 using namespace llvm::support;
981 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
982 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
983 Val.insert(Reader.getGlobalDeclID(F, LocalID));
984 }
985 }
986
ReadLexicalDeclContextStorage(ModuleFile & M,BitstreamCursor & Cursor,uint64_t Offset,DeclContext * DC)987 bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
988 BitstreamCursor &Cursor,
989 uint64_t Offset,
990 DeclContext *DC) {
991 assert(Offset != 0);
992
993 SavedStreamPosition SavedPosition(Cursor);
994 Cursor.JumpToBit(Offset);
995
996 RecordData Record;
997 StringRef Blob;
998 unsigned Code = Cursor.ReadCode();
999 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1000 if (RecCode != DECL_CONTEXT_LEXICAL) {
1001 Error("Expected lexical block");
1002 return true;
1003 }
1004
1005 assert(!isa<TranslationUnitDecl>(DC) &&
1006 "expected a TU_UPDATE_LEXICAL record for TU");
1007 // If we are handling a C++ class template instantiation, we can see multiple
1008 // lexical updates for the same record. It's important that we select only one
1009 // of them, so that field numbering works properly. Just pick the first one we
1010 // see.
1011 auto &Lex = LexicalDecls[DC];
1012 if (!Lex.first) {
1013 Lex = std::make_pair(
1014 &M, llvm::makeArrayRef(
1015 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1016 Blob.data()),
1017 Blob.size() / 4));
1018 }
1019 DC->setHasExternalLexicalStorage(true);
1020 return false;
1021 }
1022
ReadVisibleDeclContextStorage(ModuleFile & M,BitstreamCursor & Cursor,uint64_t Offset,DeclID ID)1023 bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1024 BitstreamCursor &Cursor,
1025 uint64_t Offset,
1026 DeclID ID) {
1027 assert(Offset != 0);
1028
1029 SavedStreamPosition SavedPosition(Cursor);
1030 Cursor.JumpToBit(Offset);
1031
1032 RecordData Record;
1033 StringRef Blob;
1034 unsigned Code = Cursor.ReadCode();
1035 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1036 if (RecCode != DECL_CONTEXT_VISIBLE) {
1037 Error("Expected visible lookup table block");
1038 return true;
1039 }
1040
1041 // We can't safely determine the primary context yet, so delay attaching the
1042 // lookup table until we're done with recursive deserialization.
1043 auto *Data = (const unsigned char*)Blob.data();
1044 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
1045 return false;
1046 }
1047
Error(StringRef Msg)1048 void ASTReader::Error(StringRef Msg) {
1049 Error(diag::err_fe_pch_malformed, Msg);
1050 if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1051 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
1052 Diag(diag::note_module_cache_path)
1053 << PP.getHeaderSearchInfo().getModuleCachePath();
1054 }
1055 }
1056
Error(unsigned DiagID,StringRef Arg1,StringRef Arg2)1057 void ASTReader::Error(unsigned DiagID,
1058 StringRef Arg1, StringRef Arg2) {
1059 if (Diags.isDiagnosticInFlight())
1060 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1061 else
1062 Diag(DiagID) << Arg1 << Arg2;
1063 }
1064
1065 //===----------------------------------------------------------------------===//
1066 // Source Manager Deserialization
1067 //===----------------------------------------------------------------------===//
1068
1069 /// \brief Read the line table in the source manager block.
1070 /// \returns true if there was an error.
ParseLineTable(ModuleFile & F,const RecordData & Record)1071 bool ASTReader::ParseLineTable(ModuleFile &F,
1072 const RecordData &Record) {
1073 unsigned Idx = 0;
1074 LineTableInfo &LineTable = SourceMgr.getLineTable();
1075
1076 // Parse the file names
1077 std::map<int, int> FileIDs;
1078 for (unsigned I = 0; Record[Idx]; ++I) {
1079 // Extract the file name
1080 auto Filename = ReadPath(F, Record, Idx);
1081 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1082 }
1083 ++Idx;
1084
1085 // Parse the line entries
1086 std::vector<LineEntry> Entries;
1087 while (Idx < Record.size()) {
1088 int FID = Record[Idx++];
1089 assert(FID >= 0 && "Serialized line entries for non-local file.");
1090 // Remap FileID from 1-based old view.
1091 FID += F.SLocEntryBaseID - 1;
1092
1093 // Extract the line entries
1094 unsigned NumEntries = Record[Idx++];
1095 assert(NumEntries && "no line entries for file ID");
1096 Entries.clear();
1097 Entries.reserve(NumEntries);
1098 for (unsigned I = 0; I != NumEntries; ++I) {
1099 unsigned FileOffset = Record[Idx++];
1100 unsigned LineNo = Record[Idx++];
1101 int FilenameID = FileIDs[Record[Idx++]];
1102 SrcMgr::CharacteristicKind FileKind
1103 = (SrcMgr::CharacteristicKind)Record[Idx++];
1104 unsigned IncludeOffset = Record[Idx++];
1105 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1106 FileKind, IncludeOffset));
1107 }
1108 LineTable.AddEntry(FileID::get(FID), Entries);
1109 }
1110
1111 return false;
1112 }
1113
1114 /// \brief Read a source manager block
ReadSourceManagerBlock(ModuleFile & F)1115 bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1116 using namespace SrcMgr;
1117
1118 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
1119
1120 // Set the source-location entry cursor to the current position in
1121 // the stream. This cursor will be used to read the contents of the
1122 // source manager block initially, and then lazily read
1123 // source-location entries as needed.
1124 SLocEntryCursor = F.Stream;
1125
1126 // The stream itself is going to skip over the source manager block.
1127 if (F.Stream.SkipBlock()) {
1128 Error("malformed block record in AST file");
1129 return true;
1130 }
1131
1132 // Enter the source manager block.
1133 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1134 Error("malformed source manager block record in AST file");
1135 return true;
1136 }
1137
1138 RecordData Record;
1139 while (true) {
1140 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1141
1142 switch (E.Kind) {
1143 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1144 case llvm::BitstreamEntry::Error:
1145 Error("malformed block record in AST file");
1146 return true;
1147 case llvm::BitstreamEntry::EndBlock:
1148 return false;
1149 case llvm::BitstreamEntry::Record:
1150 // The interesting case.
1151 break;
1152 }
1153
1154 // Read a record.
1155 Record.clear();
1156 StringRef Blob;
1157 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
1158 default: // Default behavior: ignore.
1159 break;
1160
1161 case SM_SLOC_FILE_ENTRY:
1162 case SM_SLOC_BUFFER_ENTRY:
1163 case SM_SLOC_EXPANSION_ENTRY:
1164 // Once we hit one of the source location entries, we're done.
1165 return false;
1166 }
1167 }
1168 }
1169
1170 /// \brief If a header file is not found at the path that we expect it to be
1171 /// and the PCH file was moved from its original location, try to resolve the
1172 /// file by assuming that header+PCH were moved together and the header is in
1173 /// the same place relative to the PCH.
1174 static std::string
resolveFileRelativeToOriginalDir(const std::string & Filename,const std::string & OriginalDir,const std::string & CurrDir)1175 resolveFileRelativeToOriginalDir(const std::string &Filename,
1176 const std::string &OriginalDir,
1177 const std::string &CurrDir) {
1178 assert(OriginalDir != CurrDir &&
1179 "No point trying to resolve the file if the PCH dir didn't change");
1180 using namespace llvm::sys;
1181 SmallString<128> filePath(Filename);
1182 fs::make_absolute(filePath);
1183 assert(path::is_absolute(OriginalDir));
1184 SmallString<128> currPCHPath(CurrDir);
1185
1186 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1187 fileDirE = path::end(path::parent_path(filePath));
1188 path::const_iterator origDirI = path::begin(OriginalDir),
1189 origDirE = path::end(OriginalDir);
1190 // Skip the common path components from filePath and OriginalDir.
1191 while (fileDirI != fileDirE && origDirI != origDirE &&
1192 *fileDirI == *origDirI) {
1193 ++fileDirI;
1194 ++origDirI;
1195 }
1196 for (; origDirI != origDirE; ++origDirI)
1197 path::append(currPCHPath, "..");
1198 path::append(currPCHPath, fileDirI, fileDirE);
1199 path::append(currPCHPath, path::filename(Filename));
1200 return currPCHPath.str();
1201 }
1202
ReadSLocEntry(int ID)1203 bool ASTReader::ReadSLocEntry(int ID) {
1204 if (ID == 0)
1205 return false;
1206
1207 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1208 Error("source location entry ID out-of-range for AST file");
1209 return true;
1210 }
1211
1212 // Local helper to read the (possibly-compressed) buffer data following the
1213 // entry record.
1214 auto ReadBuffer = [this](
1215 BitstreamCursor &SLocEntryCursor,
1216 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1217 RecordData Record;
1218 StringRef Blob;
1219 unsigned Code = SLocEntryCursor.ReadCode();
1220 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1221
1222 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1223 SmallString<0> Uncompressed;
1224 if (llvm::zlib::uncompress(Blob, Uncompressed, Record[0]) !=
1225 llvm::zlib::StatusOK) {
1226 Error("could not decompress embedded file contents");
1227 return nullptr;
1228 }
1229 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1230 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1231 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1232 } else {
1233 Error("AST record has invalid code");
1234 return nullptr;
1235 }
1236 };
1237
1238 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1239 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
1240 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
1241 unsigned BaseOffset = F->SLocEntryBaseOffset;
1242
1243 ++NumSLocEntriesRead;
1244 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1245 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1246 Error("incorrectly-formatted source location entry in AST file");
1247 return true;
1248 }
1249
1250 RecordData Record;
1251 StringRef Blob;
1252 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
1253 default:
1254 Error("incorrectly-formatted source location entry in AST file");
1255 return true;
1256
1257 case SM_SLOC_FILE_ENTRY: {
1258 // We will detect whether a file changed and return 'Failure' for it, but
1259 // we will also try to fail gracefully by setting up the SLocEntry.
1260 unsigned InputID = Record[4];
1261 InputFile IF = getInputFile(*F, InputID);
1262 const FileEntry *File = IF.getFile();
1263 bool OverriddenBuffer = IF.isOverridden();
1264
1265 // Note that we only check if a File was returned. If it was out-of-date
1266 // we have complained but we will continue creating a FileID to recover
1267 // gracefully.
1268 if (!File)
1269 return true;
1270
1271 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1272 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1273 // This is the module's main file.
1274 IncludeLoc = getImportLocation(F);
1275 }
1276 SrcMgr::CharacteristicKind
1277 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1278 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1279 ID, BaseOffset + Record[0]);
1280 SrcMgr::FileInfo &FileInfo =
1281 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1282 FileInfo.NumCreatedFIDs = Record[5];
1283 if (Record[3])
1284 FileInfo.setHasLineDirectives();
1285
1286 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1287 unsigned NumFileDecls = Record[7];
1288 if (NumFileDecls) {
1289 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1290 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1291 NumFileDecls));
1292 }
1293
1294 const SrcMgr::ContentCache *ContentCache
1295 = SourceMgr.getOrCreateContentCache(File,
1296 /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
1297 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
1298 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1299 !ContentCache->getRawBuffer()) {
1300 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1301 if (!Buffer)
1302 return true;
1303 SourceMgr.overrideFileContents(File, std::move(Buffer));
1304 }
1305
1306 break;
1307 }
1308
1309 case SM_SLOC_BUFFER_ENTRY: {
1310 const char *Name = Blob.data();
1311 unsigned Offset = Record[0];
1312 SrcMgr::CharacteristicKind
1313 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1314 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1315 if (IncludeLoc.isInvalid() &&
1316 (F->Kind == MK_ImplicitModule || F->Kind == MK_ExplicitModule)) {
1317 IncludeLoc = getImportLocation(F);
1318 }
1319
1320 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1321 if (!Buffer)
1322 return true;
1323 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
1324 BaseOffset + Offset, IncludeLoc);
1325 break;
1326 }
1327
1328 case SM_SLOC_EXPANSION_ENTRY: {
1329 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1330 SourceMgr.createExpansionLoc(SpellingLoc,
1331 ReadSourceLocation(*F, Record[2]),
1332 ReadSourceLocation(*F, Record[3]),
1333 Record[4],
1334 ID,
1335 BaseOffset + Record[0]);
1336 break;
1337 }
1338 }
1339
1340 return false;
1341 }
1342
getModuleImportLoc(int ID)1343 std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1344 if (ID == 0)
1345 return std::make_pair(SourceLocation(), "");
1346
1347 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1348 Error("source location entry ID out-of-range for AST file");
1349 return std::make_pair(SourceLocation(), "");
1350 }
1351
1352 // Find which module file this entry lands in.
1353 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
1354 if (M->Kind != MK_ImplicitModule && M->Kind != MK_ExplicitModule)
1355 return std::make_pair(SourceLocation(), "");
1356
1357 // FIXME: Can we map this down to a particular submodule? That would be
1358 // ideal.
1359 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
1360 }
1361
1362 /// \brief Find the location where the module F is imported.
getImportLocation(ModuleFile * F)1363 SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1364 if (F->ImportLoc.isValid())
1365 return F->ImportLoc;
1366
1367 // Otherwise we have a PCH. It's considered to be "imported" at the first
1368 // location of its includer.
1369 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
1370 // Main file is the importer.
1371 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
1372 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
1373 }
1374 return F->ImportedBy[0]->FirstLoc;
1375 }
1376
1377 /// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1378 /// specified cursor. Read the abbreviations that are at the top of the block
1379 /// and then leave the cursor pointing into the block.
ReadBlockAbbrevs(BitstreamCursor & Cursor,unsigned BlockID)1380 bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
1381 if (Cursor.EnterSubBlock(BlockID))
1382 return true;
1383
1384 while (true) {
1385 uint64_t Offset = Cursor.GetCurrentBitNo();
1386 unsigned Code = Cursor.ReadCode();
1387
1388 // We expect all abbrevs to be at the start of the block.
1389 if (Code != llvm::bitc::DEFINE_ABBREV) {
1390 Cursor.JumpToBit(Offset);
1391 return false;
1392 }
1393 Cursor.ReadAbbrevRecord();
1394 }
1395 }
1396
ReadToken(ModuleFile & F,const RecordDataImpl & Record,unsigned & Idx)1397 Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
1398 unsigned &Idx) {
1399 Token Tok;
1400 Tok.startToken();
1401 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1402 Tok.setLength(Record[Idx++]);
1403 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1404 Tok.setIdentifierInfo(II);
1405 Tok.setKind((tok::TokenKind)Record[Idx++]);
1406 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1407 return Tok;
1408 }
1409
ReadMacroRecord(ModuleFile & F,uint64_t Offset)1410 MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
1411 BitstreamCursor &Stream = F.MacroCursor;
1412
1413 // Keep track of where we are in the stream, then jump back there
1414 // after reading this macro.
1415 SavedStreamPosition SavedPosition(Stream);
1416
1417 Stream.JumpToBit(Offset);
1418 RecordData Record;
1419 SmallVector<IdentifierInfo*, 16> MacroArgs;
1420 MacroInfo *Macro = nullptr;
1421
1422 while (true) {
1423 // Advance to the next record, but if we get to the end of the block, don't
1424 // pop it (removing all the abbreviations from the cursor) since we want to
1425 // be able to reseek within the block and read entries.
1426 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
1427 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1428
1429 switch (Entry.Kind) {
1430 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1431 case llvm::BitstreamEntry::Error:
1432 Error("malformed block record in AST file");
1433 return Macro;
1434 case llvm::BitstreamEntry::EndBlock:
1435 return Macro;
1436 case llvm::BitstreamEntry::Record:
1437 // The interesting case.
1438 break;
1439 }
1440
1441 // Read a record.
1442 Record.clear();
1443 PreprocessorRecordTypes RecType =
1444 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
1445 switch (RecType) {
1446 case PP_MODULE_MACRO:
1447 case PP_MACRO_DIRECTIVE_HISTORY:
1448 return Macro;
1449
1450 case PP_MACRO_OBJECT_LIKE:
1451 case PP_MACRO_FUNCTION_LIKE: {
1452 // If we already have a macro, that means that we've hit the end
1453 // of the definition of the macro we were looking for. We're
1454 // done.
1455 if (Macro)
1456 return Macro;
1457
1458 unsigned NextIndex = 1; // Skip identifier ID.
1459 SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]);
1460 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
1461 MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID);
1462 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
1463 MI->setIsUsed(Record[NextIndex++]);
1464 MI->setUsedForHeaderGuard(Record[NextIndex++]);
1465
1466 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1467 // Decode function-like macro info.
1468 bool isC99VarArgs = Record[NextIndex++];
1469 bool isGNUVarArgs = Record[NextIndex++];
1470 bool hasCommaPasting = Record[NextIndex++];
1471 MacroArgs.clear();
1472 unsigned NumArgs = Record[NextIndex++];
1473 for (unsigned i = 0; i != NumArgs; ++i)
1474 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1475
1476 // Install function-like macro info.
1477 MI->setIsFunctionLike();
1478 if (isC99VarArgs) MI->setIsC99Varargs();
1479 if (isGNUVarArgs) MI->setIsGNUVarargs();
1480 if (hasCommaPasting) MI->setHasCommaPasting();
1481 MI->setArgumentList(MacroArgs, PP.getPreprocessorAllocator());
1482 }
1483
1484 // Remember that we saw this macro last so that we add the tokens that
1485 // form its body to it.
1486 Macro = MI;
1487
1488 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1489 Record[NextIndex]) {
1490 // We have a macro definition. Register the association
1491 PreprocessedEntityID
1492 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1493 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
1494 PreprocessingRecord::PPEntityID PPID =
1495 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1496 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1497 PPRec.getPreprocessedEntity(PPID));
1498 if (PPDef)
1499 PPRec.RegisterMacroDefinition(Macro, PPDef);
1500 }
1501
1502 ++NumMacrosRead;
1503 break;
1504 }
1505
1506 case PP_TOKEN: {
1507 // If we see a TOKEN before a PP_MACRO_*, then the file is
1508 // erroneous, just pretend we didn't see this.
1509 if (!Macro) break;
1510
1511 unsigned Idx = 0;
1512 Token Tok = ReadToken(F, Record, Idx);
1513 Macro->AddTokenToBody(Tok);
1514 break;
1515 }
1516 }
1517 }
1518 }
1519
1520 PreprocessedEntityID
getGlobalPreprocessedEntityID(ModuleFile & M,unsigned LocalID) const1521 ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
1522 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1523 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1524 assert(I != M.PreprocessedEntityRemap.end()
1525 && "Invalid index into preprocessed entity index remap");
1526
1527 return LocalID + I->second;
1528 }
1529
ComputeHash(internal_key_ref ikey)1530 unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1531 return llvm::hash_combine(ikey.Size, ikey.ModTime);
1532 }
1533
1534 HeaderFileInfoTrait::internal_key_type
GetInternalKey(const FileEntry * FE)1535 HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
1536 internal_key_type ikey = {FE->getSize(),
1537 M.HasTimestamps ? FE->getModificationTime() : 0,
1538 FE->getName(), /*Imported*/ false};
1539 return ikey;
1540 }
1541
EqualKey(internal_key_ref a,internal_key_ref b)1542 bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
1543 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
1544 return false;
1545
1546 if (llvm::sys::path::is_absolute(a.Filename) &&
1547 strcmp(a.Filename, b.Filename) == 0)
1548 return true;
1549
1550 // Determine whether the actual files are equivalent.
1551 FileManager &FileMgr = Reader.getFileManager();
1552 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1553 if (!Key.Imported)
1554 return FileMgr.getFile(Key.Filename);
1555
1556 std::string Resolved = Key.Filename;
1557 Reader.ResolveImportedPath(M, Resolved);
1558 return FileMgr.getFile(Resolved);
1559 };
1560
1561 const FileEntry *FEA = GetFile(a);
1562 const FileEntry *FEB = GetFile(b);
1563 return FEA && FEA == FEB;
1564 }
1565
1566 std::pair<unsigned, unsigned>
ReadKeyDataLength(const unsigned char * & d)1567 HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
1568 using namespace llvm::support;
1569 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
1570 unsigned DataLen = (unsigned) *d++;
1571 return std::make_pair(KeyLen, DataLen);
1572 }
1573
1574 HeaderFileInfoTrait::internal_key_type
ReadKey(const unsigned char * d,unsigned)1575 HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
1576 using namespace llvm::support;
1577 internal_key_type ikey;
1578 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1579 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
1580 ikey.Filename = (const char *)d;
1581 ikey.Imported = true;
1582 return ikey;
1583 }
1584
1585 HeaderFileInfoTrait::data_type
ReadData(internal_key_ref key,const unsigned char * d,unsigned DataLen)1586 HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
1587 unsigned DataLen) {
1588 const unsigned char *End = d + DataLen;
1589 using namespace llvm::support;
1590 HeaderFileInfo HFI;
1591 unsigned Flags = *d++;
1592 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1593 HFI.isImport |= (Flags >> 4) & 0x01;
1594 HFI.isPragmaOnce |= (Flags >> 3) & 0x01;
1595 HFI.DirInfo = (Flags >> 1) & 0x03;
1596 HFI.IndexHeaderMapHeader = Flags & 0x01;
1597 // FIXME: Find a better way to handle this. Maybe just store a
1598 // "has been included" flag?
1599 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1600 HFI.NumIncludes);
1601 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1602 M, endian::readNext<uint32_t, little, unaligned>(d));
1603 if (unsigned FrameworkOffset =
1604 endian::readNext<uint32_t, little, unaligned>(d)) {
1605 // The framework offset is 1 greater than the actual offset,
1606 // since 0 is used as an indicator for "no framework name".
1607 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1608 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1609 }
1610
1611 assert((End - d) % 4 == 0 &&
1612 "Wrong data length in HeaderFileInfo deserialization");
1613 while (d != End) {
1614 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
1615 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1616 LocalSMID >>= 2;
1617
1618 // This header is part of a module. Associate it with the module to enable
1619 // implicit module import.
1620 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1621 Module *Mod = Reader.getSubmodule(GlobalSMID);
1622 FileManager &FileMgr = Reader.getFileManager();
1623 ModuleMap &ModMap =
1624 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1625
1626 std::string Filename = key.Filename;
1627 if (key.Imported)
1628 Reader.ResolveImportedPath(M, Filename);
1629 // FIXME: This is not always the right filename-as-written, but we're not
1630 // going to use this information to rebuild the module, so it doesn't make
1631 // a lot of difference.
1632 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
1633 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1634 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
1635 }
1636
1637 // This HeaderFileInfo was externally loaded.
1638 HFI.External = true;
1639 HFI.IsValid = true;
1640 return HFI;
1641 }
1642
addPendingMacro(IdentifierInfo * II,ModuleFile * M,uint64_t MacroDirectivesOffset)1643 void ASTReader::addPendingMacro(IdentifierInfo *II,
1644 ModuleFile *M,
1645 uint64_t MacroDirectivesOffset) {
1646 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1647 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
1648 }
1649
ReadDefinedMacros()1650 void ASTReader::ReadDefinedMacros() {
1651 // Note that we are loading defined macros.
1652 Deserializing Macros(this);
1653
1654 for (auto &I : llvm::reverse(ModuleMgr)) {
1655 BitstreamCursor &MacroCursor = I->MacroCursor;
1656
1657 // If there was no preprocessor block, skip this file.
1658 if (!MacroCursor.getBitStreamReader())
1659 continue;
1660
1661 BitstreamCursor Cursor = MacroCursor;
1662 Cursor.JumpToBit(I->MacroStartOffset);
1663
1664 RecordData Record;
1665 while (true) {
1666 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1667
1668 switch (E.Kind) {
1669 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1670 case llvm::BitstreamEntry::Error:
1671 Error("malformed block record in AST file");
1672 return;
1673 case llvm::BitstreamEntry::EndBlock:
1674 goto NextCursor;
1675
1676 case llvm::BitstreamEntry::Record:
1677 Record.clear();
1678 switch (Cursor.readRecord(E.ID, Record)) {
1679 default: // Default behavior: ignore.
1680 break;
1681
1682 case PP_MACRO_OBJECT_LIKE:
1683 case PP_MACRO_FUNCTION_LIKE: {
1684 IdentifierInfo *II = getLocalIdentifier(*I, Record[0]);
1685 if (II->isOutOfDate())
1686 updateOutOfDateIdentifier(*II);
1687 break;
1688 }
1689
1690 case PP_TOKEN:
1691 // Ignore tokens.
1692 break;
1693 }
1694 break;
1695 }
1696 }
1697 NextCursor: ;
1698 }
1699 }
1700
1701 namespace {
1702 /// \brief Visitor class used to look up identifirs in an AST file.
1703 class IdentifierLookupVisitor {
1704 StringRef Name;
1705 unsigned NameHash;
1706 unsigned PriorGeneration;
1707 unsigned &NumIdentifierLookups;
1708 unsigned &NumIdentifierLookupHits;
1709 IdentifierInfo *Found;
1710
1711 public:
IdentifierLookupVisitor(StringRef Name,unsigned PriorGeneration,unsigned & NumIdentifierLookups,unsigned & NumIdentifierLookupHits)1712 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1713 unsigned &NumIdentifierLookups,
1714 unsigned &NumIdentifierLookupHits)
1715 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1716 PriorGeneration(PriorGeneration),
1717 NumIdentifierLookups(NumIdentifierLookups),
1718 NumIdentifierLookupHits(NumIdentifierLookupHits),
1719 Found()
1720 {
1721 }
1722
operator ()(ModuleFile & M)1723 bool operator()(ModuleFile &M) {
1724 // If we've already searched this module file, skip it now.
1725 if (M.Generation <= PriorGeneration)
1726 return true;
1727
1728 ASTIdentifierLookupTable *IdTable
1729 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1730 if (!IdTable)
1731 return false;
1732
1733 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
1734 Found);
1735 ++NumIdentifierLookups;
1736 ASTIdentifierLookupTable::iterator Pos =
1737 IdTable->find_hashed(Name, NameHash, &Trait);
1738 if (Pos == IdTable->end())
1739 return false;
1740
1741 // Dereferencing the iterator has the effect of building the
1742 // IdentifierInfo node and populating it with the various
1743 // declarations it needs.
1744 ++NumIdentifierLookupHits;
1745 Found = *Pos;
1746 return true;
1747 }
1748
1749 // \brief Retrieve the identifier info found within the module
1750 // files.
getIdentifierInfo() const1751 IdentifierInfo *getIdentifierInfo() const { return Found; }
1752 };
1753 }
1754
updateOutOfDateIdentifier(IdentifierInfo & II)1755 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1756 // Note that we are loading an identifier.
1757 Deserializing AnIdentifier(this);
1758
1759 unsigned PriorGeneration = 0;
1760 if (getContext().getLangOpts().Modules)
1761 PriorGeneration = IdentifierGeneration[&II];
1762
1763 // If there is a global index, look there first to determine which modules
1764 // provably do not have any results for this identifier.
1765 GlobalModuleIndex::HitSet Hits;
1766 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
1767 if (!loadGlobalIndex()) {
1768 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1769 HitsPtr = &Hits;
1770 }
1771 }
1772
1773 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
1774 NumIdentifierLookups,
1775 NumIdentifierLookupHits);
1776 ModuleMgr.visit(Visitor, HitsPtr);
1777 markIdentifierUpToDate(&II);
1778 }
1779
markIdentifierUpToDate(IdentifierInfo * II)1780 void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1781 if (!II)
1782 return;
1783
1784 II->setOutOfDate(false);
1785
1786 // Update the generation for this identifier.
1787 if (getContext().getLangOpts().Modules)
1788 IdentifierGeneration[II] = getGeneration();
1789 }
1790
resolvePendingMacro(IdentifierInfo * II,const PendingMacroInfo & PMInfo)1791 void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1792 const PendingMacroInfo &PMInfo) {
1793 ModuleFile &M = *PMInfo.M;
1794
1795 BitstreamCursor &Cursor = M.MacroCursor;
1796 SavedStreamPosition SavedPosition(Cursor);
1797 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
1798
1799 struct ModuleMacroRecord {
1800 SubmoduleID SubModID;
1801 MacroInfo *MI;
1802 SmallVector<SubmoduleID, 8> Overrides;
1803 };
1804 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
1805
1806 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1807 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1808 // macro histroy.
1809 RecordData Record;
1810 while (true) {
1811 llvm::BitstreamEntry Entry =
1812 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1813 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1814 Error("malformed block record in AST file");
1815 return;
1816 }
1817
1818 Record.clear();
1819 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
1820 case PP_MACRO_DIRECTIVE_HISTORY:
1821 break;
1822
1823 case PP_MODULE_MACRO: {
1824 ModuleMacros.push_back(ModuleMacroRecord());
1825 auto &Info = ModuleMacros.back();
1826 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1827 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
1828 for (int I = 2, N = Record.size(); I != N; ++I)
1829 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
1830 continue;
1831 }
1832
1833 default:
1834 Error("malformed block record in AST file");
1835 return;
1836 }
1837
1838 // We found the macro directive history; that's the last record
1839 // for this macro.
1840 break;
1841 }
1842
1843 // Module macros are listed in reverse dependency order.
1844 {
1845 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
1846 llvm::SmallVector<ModuleMacro*, 8> Overrides;
1847 for (auto &MMR : ModuleMacros) {
1848 Overrides.clear();
1849 for (unsigned ModID : MMR.Overrides) {
1850 Module *Mod = getSubmodule(ModID);
1851 auto *Macro = PP.getModuleMacro(Mod, II);
1852 assert(Macro && "missing definition for overridden macro");
1853 Overrides.push_back(Macro);
1854 }
1855
1856 bool Inserted = false;
1857 Module *Owner = getSubmodule(MMR.SubModID);
1858 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
1859 }
1860 }
1861
1862 // Don't read the directive history for a module; we don't have anywhere
1863 // to put it.
1864 if (M.Kind == MK_ImplicitModule || M.Kind == MK_ExplicitModule)
1865 return;
1866
1867 // Deserialize the macro directives history in reverse source-order.
1868 MacroDirective *Latest = nullptr, *Earliest = nullptr;
1869 unsigned Idx = 0, N = Record.size();
1870 while (Idx < N) {
1871 MacroDirective *MD = nullptr;
1872 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
1873 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
1874 switch (K) {
1875 case MacroDirective::MD_Define: {
1876 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
1877 MD = PP.AllocateDefMacroDirective(MI, Loc);
1878 break;
1879 }
1880 case MacroDirective::MD_Undefine: {
1881 MD = PP.AllocateUndefMacroDirective(Loc);
1882 break;
1883 }
1884 case MacroDirective::MD_Visibility:
1885 bool isPublic = Record[Idx++];
1886 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
1887 break;
1888 }
1889
1890 if (!Latest)
1891 Latest = MD;
1892 if (Earliest)
1893 Earliest->setPrevious(MD);
1894 Earliest = MD;
1895 }
1896
1897 if (Latest)
1898 PP.setLoadedMacroDirective(II, Latest);
1899 }
1900
1901 ASTReader::InputFileInfo
readInputFileInfo(ModuleFile & F,unsigned ID)1902 ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
1903 // Go find this input file.
1904 BitstreamCursor &Cursor = F.InputFilesCursor;
1905 SavedStreamPosition SavedPosition(Cursor);
1906 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1907
1908 unsigned Code = Cursor.ReadCode();
1909 RecordData Record;
1910 StringRef Blob;
1911
1912 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
1913 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
1914 "invalid record type for input file");
1915 (void)Result;
1916
1917 assert(Record[0] == ID && "Bogus stored ID or offset");
1918 InputFileInfo R;
1919 R.StoredSize = static_cast<off_t>(Record[1]);
1920 R.StoredTime = static_cast<time_t>(Record[2]);
1921 R.Overridden = static_cast<bool>(Record[3]);
1922 R.Transient = static_cast<bool>(Record[4]);
1923 R.Filename = Blob;
1924 ResolveImportedPath(F, R.Filename);
1925 return R;
1926 }
1927
getInputFile(ModuleFile & F,unsigned ID,bool Complain)1928 InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
1929 // If this ID is bogus, just return an empty input file.
1930 if (ID == 0 || ID > F.InputFilesLoaded.size())
1931 return InputFile();
1932
1933 // If we've already loaded this input file, return it.
1934 if (F.InputFilesLoaded[ID-1].getFile())
1935 return F.InputFilesLoaded[ID-1];
1936
1937 if (F.InputFilesLoaded[ID-1].isNotFound())
1938 return InputFile();
1939
1940 // Go find this input file.
1941 BitstreamCursor &Cursor = F.InputFilesCursor;
1942 SavedStreamPosition SavedPosition(Cursor);
1943 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1944
1945 InputFileInfo FI = readInputFileInfo(F, ID);
1946 off_t StoredSize = FI.StoredSize;
1947 time_t StoredTime = FI.StoredTime;
1948 bool Overridden = FI.Overridden;
1949 bool Transient = FI.Transient;
1950 StringRef Filename = FI.Filename;
1951
1952 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
1953
1954 // If we didn't find the file, resolve it relative to the
1955 // original directory from which this AST file was created.
1956 if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
1957 F.OriginalDir != CurrentDir) {
1958 std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
1959 F.OriginalDir,
1960 CurrentDir);
1961 if (!Resolved.empty())
1962 File = FileMgr.getFile(Resolved);
1963 }
1964
1965 // For an overridden file, create a virtual file with the stored
1966 // size/timestamp.
1967 if ((Overridden || Transient) && File == nullptr)
1968 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
1969
1970 if (File == nullptr) {
1971 if (Complain) {
1972 std::string ErrorStr = "could not find file '";
1973 ErrorStr += Filename;
1974 ErrorStr += "' referenced by AST file '";
1975 ErrorStr += F.FileName;
1976 ErrorStr += "'";
1977 Error(ErrorStr.c_str());
1978 }
1979 // Record that we didn't find the file.
1980 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
1981 return InputFile();
1982 }
1983
1984 // Check if there was a request to override the contents of the file
1985 // that was part of the precompiled header. Overridding such a file
1986 // can lead to problems when lexing using the source locations from the
1987 // PCH.
1988 SourceManager &SM = getSourceManager();
1989 // FIXME: Reject if the overrides are different.
1990 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
1991 if (Complain)
1992 Error(diag::err_fe_pch_file_overridden, Filename);
1993 // After emitting the diagnostic, recover by disabling the override so
1994 // that the original file will be used.
1995 //
1996 // FIXME: This recovery is just as broken as the original state; there may
1997 // be another precompiled module that's using the overridden contents, or
1998 // we might be half way through parsing it. Instead, we should treat the
1999 // overridden contents as belonging to a separate FileEntry.
2000 SM.disableFileContentsOverride(File);
2001 // The FileEntry is a virtual file entry with the size of the contents
2002 // that would override the original contents. Set it to the original's
2003 // size/time.
2004 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
2005 StoredSize, StoredTime);
2006 }
2007
2008 bool IsOutOfDate = false;
2009
2010 // For an overridden file, there is nothing to validate.
2011 if (!Overridden && //
2012 (StoredSize != File->getSize() ||
2013 (StoredTime && StoredTime != File->getModificationTime() &&
2014 !DisableValidation)
2015 )) {
2016 if (Complain) {
2017 // Build a list of the PCH imports that got us here (in reverse).
2018 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2019 while (ImportStack.back()->ImportedBy.size() > 0)
2020 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
2021
2022 // The top-level PCH is stale.
2023 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2024 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
2025
2026 // Print the import stack.
2027 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2028 Diag(diag::note_pch_required_by)
2029 << Filename << ImportStack[0]->FileName;
2030 for (unsigned I = 1; I < ImportStack.size(); ++I)
2031 Diag(diag::note_pch_required_by)
2032 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
2033 }
2034
2035 if (!Diags.isDiagnosticInFlight())
2036 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
2037 }
2038
2039 IsOutOfDate = true;
2040 }
2041 // FIXME: If the file is overridden and we've already opened it,
2042 // issue an error (or split it into a separate FileEntry).
2043
2044 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
2045
2046 // Note that we've loaded this input file.
2047 F.InputFilesLoaded[ID-1] = IF;
2048 return IF;
2049 }
2050
2051 /// \brief If we are loading a relocatable PCH or module file, and the filename
2052 /// is not an absolute path, add the system or module root to the beginning of
2053 /// the file name.
ResolveImportedPath(ModuleFile & M,std::string & Filename)2054 void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2055 // Resolve relative to the base directory, if we have one.
2056 if (!M.BaseDirectory.empty())
2057 return ResolveImportedPath(Filename, M.BaseDirectory);
2058 }
2059
ResolveImportedPath(std::string & Filename,StringRef Prefix)2060 void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
2061 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2062 return;
2063
2064 SmallString<128> Buffer;
2065 llvm::sys::path::append(Buffer, Prefix, Filename);
2066 Filename.assign(Buffer.begin(), Buffer.end());
2067 }
2068
isDiagnosedResult(ASTReader::ASTReadResult ARR,unsigned Caps)2069 static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2070 switch (ARR) {
2071 case ASTReader::Failure: return true;
2072 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2073 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2074 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2075 case ASTReader::ConfigurationMismatch:
2076 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2077 case ASTReader::HadErrors: return true;
2078 case ASTReader::Success: return false;
2079 }
2080
2081 llvm_unreachable("unknown ASTReadResult");
2082 }
2083
ReadOptionsBlock(BitstreamCursor & Stream,unsigned ClientLoadCapabilities,bool AllowCompatibleConfigurationMismatch,ASTReaderListener & Listener,std::string & SuggestedPredefines)2084 ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2085 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2086 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2087 std::string &SuggestedPredefines) {
2088 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2089 return Failure;
2090
2091 // Read all of the records in the options block.
2092 RecordData Record;
2093 ASTReadResult Result = Success;
2094 while (1) {
2095 llvm::BitstreamEntry Entry = Stream.advance();
2096
2097 switch (Entry.Kind) {
2098 case llvm::BitstreamEntry::Error:
2099 case llvm::BitstreamEntry::SubBlock:
2100 return Failure;
2101
2102 case llvm::BitstreamEntry::EndBlock:
2103 return Result;
2104
2105 case llvm::BitstreamEntry::Record:
2106 // The interesting case.
2107 break;
2108 }
2109
2110 // Read and process a record.
2111 Record.clear();
2112 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2113 case LANGUAGE_OPTIONS: {
2114 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2115 if (ParseLanguageOptions(Record, Complain, Listener,
2116 AllowCompatibleConfigurationMismatch))
2117 Result = ConfigurationMismatch;
2118 break;
2119 }
2120
2121 case TARGET_OPTIONS: {
2122 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2123 if (ParseTargetOptions(Record, Complain, Listener,
2124 AllowCompatibleConfigurationMismatch))
2125 Result = ConfigurationMismatch;
2126 break;
2127 }
2128
2129 case DIAGNOSTIC_OPTIONS: {
2130 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2131 if (!AllowCompatibleConfigurationMismatch &&
2132 ParseDiagnosticOptions(Record, Complain, Listener))
2133 return OutOfDate;
2134 break;
2135 }
2136
2137 case FILE_SYSTEM_OPTIONS: {
2138 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2139 if (!AllowCompatibleConfigurationMismatch &&
2140 ParseFileSystemOptions(Record, Complain, Listener))
2141 Result = ConfigurationMismatch;
2142 break;
2143 }
2144
2145 case HEADER_SEARCH_OPTIONS: {
2146 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2147 if (!AllowCompatibleConfigurationMismatch &&
2148 ParseHeaderSearchOptions(Record, Complain, Listener))
2149 Result = ConfigurationMismatch;
2150 break;
2151 }
2152
2153 case PREPROCESSOR_OPTIONS:
2154 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2155 if (!AllowCompatibleConfigurationMismatch &&
2156 ParsePreprocessorOptions(Record, Complain, Listener,
2157 SuggestedPredefines))
2158 Result = ConfigurationMismatch;
2159 break;
2160 }
2161 }
2162 }
2163
2164 ASTReader::ASTReadResult
ReadControlBlock(ModuleFile & F,SmallVectorImpl<ImportedModule> & Loaded,const ModuleFile * ImportedBy,unsigned ClientLoadCapabilities)2165 ASTReader::ReadControlBlock(ModuleFile &F,
2166 SmallVectorImpl<ImportedModule> &Loaded,
2167 const ModuleFile *ImportedBy,
2168 unsigned ClientLoadCapabilities) {
2169 BitstreamCursor &Stream = F.Stream;
2170 ASTReadResult Result = Success;
2171
2172 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2173 Error("malformed block record in AST file");
2174 return Failure;
2175 }
2176
2177 // Read all of the records and blocks in the control block.
2178 RecordData Record;
2179 unsigned NumInputs = 0;
2180 unsigned NumUserInputs = 0;
2181 while (1) {
2182 llvm::BitstreamEntry Entry = Stream.advance();
2183
2184 switch (Entry.Kind) {
2185 case llvm::BitstreamEntry::Error:
2186 Error("malformed block record in AST file");
2187 return Failure;
2188 case llvm::BitstreamEntry::EndBlock: {
2189 // Validate input files.
2190 const HeaderSearchOptions &HSOpts =
2191 PP.getHeaderSearchInfo().getHeaderSearchOpts();
2192
2193 // All user input files reside at the index range [0, NumUserInputs), and
2194 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2195 // loaded module files, ignore missing inputs.
2196 if (!DisableValidation && F.Kind != MK_ExplicitModule) {
2197 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2198
2199 // If we are reading a module, we will create a verification timestamp,
2200 // so we verify all input files. Otherwise, verify only user input
2201 // files.
2202
2203 unsigned N = NumUserInputs;
2204 if (ValidateSystemInputs ||
2205 (HSOpts.ModulesValidateOncePerBuildSession &&
2206 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
2207 F.Kind == MK_ImplicitModule))
2208 N = NumInputs;
2209
2210 for (unsigned I = 0; I < N; ++I) {
2211 InputFile IF = getInputFile(F, I+1, Complain);
2212 if (!IF.getFile() || IF.isOutOfDate())
2213 return OutOfDate;
2214 }
2215 }
2216
2217 if (Listener)
2218 Listener->visitModuleFile(F.FileName, F.Kind);
2219
2220 if (Listener && Listener->needsInputFileVisitation()) {
2221 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2222 : NumUserInputs;
2223 for (unsigned I = 0; I < N; ++I) {
2224 bool IsSystem = I >= NumUserInputs;
2225 InputFileInfo FI = readInputFileInfo(F, I+1);
2226 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2227 F.Kind == MK_ExplicitModule);
2228 }
2229 }
2230
2231 return Result;
2232 }
2233
2234 case llvm::BitstreamEntry::SubBlock:
2235 switch (Entry.ID) {
2236 case INPUT_FILES_BLOCK_ID:
2237 F.InputFilesCursor = Stream;
2238 if (Stream.SkipBlock() || // Skip with the main cursor
2239 // Read the abbreviations
2240 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2241 Error("malformed block record in AST file");
2242 return Failure;
2243 }
2244 continue;
2245
2246 case OPTIONS_BLOCK_ID:
2247 // If we're reading the first module for this group, check its options
2248 // are compatible with ours. For modules it imports, no further checking
2249 // is required, because we checked them when we built it.
2250 if (Listener && !ImportedBy) {
2251 // Should we allow the configuration of the module file to differ from
2252 // the configuration of the current translation unit in a compatible
2253 // way?
2254 //
2255 // FIXME: Allow this for files explicitly specified with -include-pch.
2256 bool AllowCompatibleConfigurationMismatch =
2257 F.Kind == MK_ExplicitModule;
2258
2259 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2260 AllowCompatibleConfigurationMismatch,
2261 *Listener, SuggestedPredefines);
2262 if (Result == Failure) {
2263 Error("malformed block record in AST file");
2264 return Result;
2265 }
2266
2267 if (DisableValidation ||
2268 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2269 Result = Success;
2270
2271 // If we can't load the module, exit early since we likely
2272 // will rebuild the module anyway. The stream may be in the
2273 // middle of a block.
2274 if (Result != Success)
2275 return Result;
2276 } else if (Stream.SkipBlock()) {
2277 Error("malformed block record in AST file");
2278 return Failure;
2279 }
2280 continue;
2281
2282 default:
2283 if (Stream.SkipBlock()) {
2284 Error("malformed block record in AST file");
2285 return Failure;
2286 }
2287 continue;
2288 }
2289
2290 case llvm::BitstreamEntry::Record:
2291 // The interesting case.
2292 break;
2293 }
2294
2295 // Read and process a record.
2296 Record.clear();
2297 StringRef Blob;
2298 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2299 case METADATA: {
2300 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2301 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2302 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2303 : diag::err_pch_version_too_new);
2304 return VersionMismatch;
2305 }
2306
2307 bool hasErrors = Record[6];
2308 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2309 Diag(diag::err_pch_with_compiler_errors);
2310 return HadErrors;
2311 }
2312 if (hasErrors) {
2313 Diags.ErrorOccurred = true;
2314 Diags.UncompilableErrorOccurred = true;
2315 Diags.UnrecoverableErrorOccurred = true;
2316 }
2317
2318 F.RelocatablePCH = Record[4];
2319 // Relative paths in a relocatable PCH are relative to our sysroot.
2320 if (F.RelocatablePCH)
2321 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
2322
2323 F.HasTimestamps = Record[5];
2324
2325 const std::string &CurBranch = getClangFullRepositoryVersion();
2326 StringRef ASTBranch = Blob;
2327 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2328 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
2329 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
2330 return VersionMismatch;
2331 }
2332 break;
2333 }
2334
2335 case SIGNATURE:
2336 assert((!F.Signature || F.Signature == Record[0]) && "signature changed");
2337 F.Signature = Record[0];
2338 break;
2339
2340 case IMPORTS: {
2341 // Load each of the imported PCH files.
2342 unsigned Idx = 0, N = Record.size();
2343 while (Idx < N) {
2344 // Read information about the AST file.
2345 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2346 // The import location will be the local one for now; we will adjust
2347 // all import locations of module imports after the global source
2348 // location info are setup, in ReadAST.
2349 SourceLocation ImportLoc =
2350 ReadUntranslatedSourceLocation(Record[Idx++]);
2351 off_t StoredSize = (off_t)Record[Idx++];
2352 time_t StoredModTime = (time_t)Record[Idx++];
2353 ASTFileSignature StoredSignature = Record[Idx++];
2354 auto ImportedFile = ReadPath(F, Record, Idx);
2355
2356 // If our client can't cope with us being out of date, we can't cope with
2357 // our dependency being missing.
2358 unsigned Capabilities = ClientLoadCapabilities;
2359 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2360 Capabilities &= ~ARR_Missing;
2361
2362 // Load the AST file.
2363 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2364 Loaded, StoredSize, StoredModTime,
2365 StoredSignature, Capabilities);
2366
2367 // If we diagnosed a problem, produce a backtrace.
2368 if (isDiagnosedResult(Result, Capabilities))
2369 Diag(diag::note_module_file_imported_by)
2370 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2371
2372 switch (Result) {
2373 case Failure: return Failure;
2374 // If we have to ignore the dependency, we'll have to ignore this too.
2375 case Missing:
2376 case OutOfDate: return OutOfDate;
2377 case VersionMismatch: return VersionMismatch;
2378 case ConfigurationMismatch: return ConfigurationMismatch;
2379 case HadErrors: return HadErrors;
2380 case Success: break;
2381 }
2382 }
2383 break;
2384 }
2385
2386 case ORIGINAL_FILE:
2387 F.OriginalSourceFileID = FileID::get(Record[0]);
2388 F.ActualOriginalSourceFileName = Blob;
2389 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
2390 ResolveImportedPath(F, F.OriginalSourceFileName);
2391 break;
2392
2393 case ORIGINAL_FILE_ID:
2394 F.OriginalSourceFileID = FileID::get(Record[0]);
2395 break;
2396
2397 case ORIGINAL_PCH_DIR:
2398 F.OriginalDir = Blob;
2399 break;
2400
2401 case MODULE_NAME:
2402 F.ModuleName = Blob;
2403 if (Listener)
2404 Listener->ReadModuleName(F.ModuleName);
2405 break;
2406
2407 case MODULE_DIRECTORY: {
2408 assert(!F.ModuleName.empty() &&
2409 "MODULE_DIRECTORY found before MODULE_NAME");
2410 // If we've already loaded a module map file covering this module, we may
2411 // have a better path for it (relative to the current build).
2412 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
2413 if (M && M->Directory) {
2414 // If we're implicitly loading a module, the base directory can't
2415 // change between the build and use.
2416 if (F.Kind != MK_ExplicitModule) {
2417 const DirectoryEntry *BuildDir =
2418 PP.getFileManager().getDirectory(Blob);
2419 if (!BuildDir || BuildDir != M->Directory) {
2420 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2421 Diag(diag::err_imported_module_relocated)
2422 << F.ModuleName << Blob << M->Directory->getName();
2423 return OutOfDate;
2424 }
2425 }
2426 F.BaseDirectory = M->Directory->getName();
2427 } else {
2428 F.BaseDirectory = Blob;
2429 }
2430 break;
2431 }
2432
2433 case MODULE_MAP_FILE:
2434 if (ASTReadResult Result =
2435 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2436 return Result;
2437 break;
2438
2439 case INPUT_FILE_OFFSETS:
2440 NumInputs = Record[0];
2441 NumUserInputs = Record[1];
2442 F.InputFileOffsets =
2443 (const llvm::support::unaligned_uint64_t *)Blob.data();
2444 F.InputFilesLoaded.resize(NumInputs);
2445 break;
2446 }
2447 }
2448 }
2449
2450 ASTReader::ASTReadResult
ReadASTBlock(ModuleFile & F,unsigned ClientLoadCapabilities)2451 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
2452 BitstreamCursor &Stream = F.Stream;
2453
2454 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2455 Error("malformed block record in AST file");
2456 return Failure;
2457 }
2458
2459 // Read all of the records and blocks for the AST file.
2460 RecordData Record;
2461 while (1) {
2462 llvm::BitstreamEntry Entry = Stream.advance();
2463
2464 switch (Entry.Kind) {
2465 case llvm::BitstreamEntry::Error:
2466 Error("error at end of module block in AST file");
2467 return Failure;
2468 case llvm::BitstreamEntry::EndBlock: {
2469 // Outside of C++, we do not store a lookup map for the translation unit.
2470 // Instead, mark it as needing a lookup map to be built if this module
2471 // contains any declarations lexically within it (which it always does!).
2472 // This usually has no cost, since we very rarely need the lookup map for
2473 // the translation unit outside C++.
2474 DeclContext *DC = Context.getTranslationUnitDecl();
2475 if (DC->hasExternalLexicalStorage() &&
2476 !getContext().getLangOpts().CPlusPlus)
2477 DC->setMustBuildLookupTable();
2478
2479 return Success;
2480 }
2481 case llvm::BitstreamEntry::SubBlock:
2482 switch (Entry.ID) {
2483 case DECLTYPES_BLOCK_ID:
2484 // We lazily load the decls block, but we want to set up the
2485 // DeclsCursor cursor to point into it. Clone our current bitcode
2486 // cursor to it, enter the block and read the abbrevs in that block.
2487 // With the main cursor, we just skip over it.
2488 F.DeclsCursor = Stream;
2489 if (Stream.SkipBlock() || // Skip with the main cursor.
2490 // Read the abbrevs.
2491 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2492 Error("malformed block record in AST file");
2493 return Failure;
2494 }
2495 break;
2496
2497 case PREPROCESSOR_BLOCK_ID:
2498 F.MacroCursor = Stream;
2499 if (!PP.getExternalSource())
2500 PP.setExternalSource(this);
2501
2502 if (Stream.SkipBlock() ||
2503 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2504 Error("malformed block record in AST file");
2505 return Failure;
2506 }
2507 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2508 break;
2509
2510 case PREPROCESSOR_DETAIL_BLOCK_ID:
2511 F.PreprocessorDetailCursor = Stream;
2512 if (Stream.SkipBlock() ||
2513 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
2514 PREPROCESSOR_DETAIL_BLOCK_ID)) {
2515 Error("malformed preprocessor detail record in AST file");
2516 return Failure;
2517 }
2518 F.PreprocessorDetailStartOffset
2519 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2520
2521 if (!PP.getPreprocessingRecord())
2522 PP.createPreprocessingRecord();
2523 if (!PP.getPreprocessingRecord()->getExternalSource())
2524 PP.getPreprocessingRecord()->SetExternalSource(*this);
2525 break;
2526
2527 case SOURCE_MANAGER_BLOCK_ID:
2528 if (ReadSourceManagerBlock(F))
2529 return Failure;
2530 break;
2531
2532 case SUBMODULE_BLOCK_ID:
2533 if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities))
2534 return Result;
2535 break;
2536
2537 case COMMENTS_BLOCK_ID: {
2538 BitstreamCursor C = Stream;
2539 if (Stream.SkipBlock() ||
2540 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2541 Error("malformed comments block in AST file");
2542 return Failure;
2543 }
2544 CommentsCursors.push_back(std::make_pair(C, &F));
2545 break;
2546 }
2547
2548 default:
2549 if (Stream.SkipBlock()) {
2550 Error("malformed block record in AST file");
2551 return Failure;
2552 }
2553 break;
2554 }
2555 continue;
2556
2557 case llvm::BitstreamEntry::Record:
2558 // The interesting case.
2559 break;
2560 }
2561
2562 // Read and process a record.
2563 Record.clear();
2564 StringRef Blob;
2565 switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
2566 default: // Default behavior: ignore.
2567 break;
2568
2569 case TYPE_OFFSET: {
2570 if (F.LocalNumTypes != 0) {
2571 Error("duplicate TYPE_OFFSET record in AST file");
2572 return Failure;
2573 }
2574 F.TypeOffsets = (const uint32_t *)Blob.data();
2575 F.LocalNumTypes = Record[0];
2576 unsigned LocalBaseTypeIndex = Record[1];
2577 F.BaseTypeIndex = getTotalNumTypes();
2578
2579 if (F.LocalNumTypes > 0) {
2580 // Introduce the global -> local mapping for types within this module.
2581 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2582
2583 // Introduce the local -> global mapping for types within this module.
2584 F.TypeRemap.insertOrReplace(
2585 std::make_pair(LocalBaseTypeIndex,
2586 F.BaseTypeIndex - LocalBaseTypeIndex));
2587
2588 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
2589 }
2590 break;
2591 }
2592
2593 case DECL_OFFSET: {
2594 if (F.LocalNumDecls != 0) {
2595 Error("duplicate DECL_OFFSET record in AST file");
2596 return Failure;
2597 }
2598 F.DeclOffsets = (const DeclOffset *)Blob.data();
2599 F.LocalNumDecls = Record[0];
2600 unsigned LocalBaseDeclID = Record[1];
2601 F.BaseDeclID = getTotalNumDecls();
2602
2603 if (F.LocalNumDecls > 0) {
2604 // Introduce the global -> local mapping for declarations within this
2605 // module.
2606 GlobalDeclMap.insert(
2607 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2608
2609 // Introduce the local -> global mapping for declarations within this
2610 // module.
2611 F.DeclRemap.insertOrReplace(
2612 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2613
2614 // Introduce the global -> local mapping for declarations within this
2615 // module.
2616 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
2617
2618 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2619 }
2620 break;
2621 }
2622
2623 case TU_UPDATE_LEXICAL: {
2624 DeclContext *TU = Context.getTranslationUnitDecl();
2625 LexicalContents Contents(
2626 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2627 Blob.data()),
2628 static_cast<unsigned int>(Blob.size() / 4));
2629 TULexicalDecls.push_back(std::make_pair(&F, Contents));
2630 TU->setHasExternalLexicalStorage(true);
2631 break;
2632 }
2633
2634 case UPDATE_VISIBLE: {
2635 unsigned Idx = 0;
2636 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
2637 auto *Data = (const unsigned char*)Blob.data();
2638 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
2639 // If we've already loaded the decl, perform the updates when we finish
2640 // loading this block.
2641 if (Decl *D = GetExistingDecl(ID))
2642 PendingUpdateRecords.push_back(std::make_pair(ID, D));
2643 break;
2644 }
2645
2646 case IDENTIFIER_TABLE:
2647 F.IdentifierTableData = Blob.data();
2648 if (Record[0]) {
2649 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2650 (const unsigned char *)F.IdentifierTableData + Record[0],
2651 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2652 (const unsigned char *)F.IdentifierTableData,
2653 ASTIdentifierLookupTrait(*this, F));
2654
2655 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2656 }
2657 break;
2658
2659 case IDENTIFIER_OFFSET: {
2660 if (F.LocalNumIdentifiers != 0) {
2661 Error("duplicate IDENTIFIER_OFFSET record in AST file");
2662 return Failure;
2663 }
2664 F.IdentifierOffsets = (const uint32_t *)Blob.data();
2665 F.LocalNumIdentifiers = Record[0];
2666 unsigned LocalBaseIdentifierID = Record[1];
2667 F.BaseIdentifierID = getTotalNumIdentifiers();
2668
2669 if (F.LocalNumIdentifiers > 0) {
2670 // Introduce the global -> local mapping for identifiers within this
2671 // module.
2672 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2673 &F));
2674
2675 // Introduce the local -> global mapping for identifiers within this
2676 // module.
2677 F.IdentifierRemap.insertOrReplace(
2678 std::make_pair(LocalBaseIdentifierID,
2679 F.BaseIdentifierID - LocalBaseIdentifierID));
2680
2681 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2682 + F.LocalNumIdentifiers);
2683 }
2684 break;
2685 }
2686
2687 case INTERESTING_IDENTIFIERS:
2688 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2689 break;
2690
2691 case EAGERLY_DESERIALIZED_DECLS:
2692 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2693 // about "interesting" decls (for instance, if we're building a module).
2694 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2695 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
2696 break;
2697
2698 case SPECIAL_TYPES:
2699 if (SpecialTypes.empty()) {
2700 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2701 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2702 break;
2703 }
2704
2705 if (SpecialTypes.size() != Record.size()) {
2706 Error("invalid special-types record");
2707 return Failure;
2708 }
2709
2710 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2711 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2712 if (!SpecialTypes[I])
2713 SpecialTypes[I] = ID;
2714 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2715 // merge step?
2716 }
2717 break;
2718
2719 case STATISTICS:
2720 TotalNumStatements += Record[0];
2721 TotalNumMacros += Record[1];
2722 TotalLexicalDeclContexts += Record[2];
2723 TotalVisibleDeclContexts += Record[3];
2724 break;
2725
2726 case UNUSED_FILESCOPED_DECLS:
2727 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2728 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2729 break;
2730
2731 case DELEGATING_CTORS:
2732 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2733 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2734 break;
2735
2736 case WEAK_UNDECLARED_IDENTIFIERS:
2737 if (Record.size() % 4 != 0) {
2738 Error("invalid weak identifiers record");
2739 return Failure;
2740 }
2741
2742 // FIXME: Ignore weak undeclared identifiers from non-original PCH
2743 // files. This isn't the way to do it :)
2744 WeakUndeclaredIdentifiers.clear();
2745
2746 // Translate the weak, undeclared identifiers into global IDs.
2747 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2748 WeakUndeclaredIdentifiers.push_back(
2749 getGlobalIdentifierID(F, Record[I++]));
2750 WeakUndeclaredIdentifiers.push_back(
2751 getGlobalIdentifierID(F, Record[I++]));
2752 WeakUndeclaredIdentifiers.push_back(
2753 ReadSourceLocation(F, Record, I).getRawEncoding());
2754 WeakUndeclaredIdentifiers.push_back(Record[I++]);
2755 }
2756 break;
2757
2758 case SELECTOR_OFFSETS: {
2759 F.SelectorOffsets = (const uint32_t *)Blob.data();
2760 F.LocalNumSelectors = Record[0];
2761 unsigned LocalBaseSelectorID = Record[1];
2762 F.BaseSelectorID = getTotalNumSelectors();
2763
2764 if (F.LocalNumSelectors > 0) {
2765 // Introduce the global -> local mapping for selectors within this
2766 // module.
2767 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2768
2769 // Introduce the local -> global mapping for selectors within this
2770 // module.
2771 F.SelectorRemap.insertOrReplace(
2772 std::make_pair(LocalBaseSelectorID,
2773 F.BaseSelectorID - LocalBaseSelectorID));
2774
2775 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
2776 }
2777 break;
2778 }
2779
2780 case METHOD_POOL:
2781 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
2782 if (Record[0])
2783 F.SelectorLookupTable
2784 = ASTSelectorLookupTable::Create(
2785 F.SelectorLookupTableData + Record[0],
2786 F.SelectorLookupTableData,
2787 ASTSelectorLookupTrait(*this, F));
2788 TotalNumMethodPoolEntries += Record[1];
2789 break;
2790
2791 case REFERENCED_SELECTOR_POOL:
2792 if (!Record.empty()) {
2793 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2794 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2795 Record[Idx++]));
2796 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2797 getRawEncoding());
2798 }
2799 }
2800 break;
2801
2802 case PP_COUNTER_VALUE:
2803 if (!Record.empty() && Listener)
2804 Listener->ReadCounter(F, Record[0]);
2805 break;
2806
2807 case FILE_SORTED_DECLS:
2808 F.FileSortedDecls = (const DeclID *)Blob.data();
2809 F.NumFileSortedDecls = Record[0];
2810 break;
2811
2812 case SOURCE_LOCATION_OFFSETS: {
2813 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
2814 F.LocalNumSLocEntries = Record[0];
2815 unsigned SLocSpaceSize = Record[1];
2816 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
2817 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
2818 SLocSpaceSize);
2819 if (!F.SLocEntryBaseID) {
2820 Error("ran out of source locations");
2821 break;
2822 }
2823 // Make our entry in the range map. BaseID is negative and growing, so
2824 // we invert it. Because we invert it, though, we need the other end of
2825 // the range.
2826 unsigned RangeStart =
2827 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2828 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2829 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2830
2831 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2832 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2833 GlobalSLocOffsetMap.insert(
2834 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2835 - SLocSpaceSize,&F));
2836
2837 // Initialize the remapping table.
2838 // Invalid stays invalid.
2839 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
2840 // This module. Base was 2 when being compiled.
2841 F.SLocRemap.insertOrReplace(std::make_pair(2U,
2842 static_cast<int>(F.SLocEntryBaseOffset - 2)));
2843
2844 TotalNumSLocEntries += F.LocalNumSLocEntries;
2845 break;
2846 }
2847
2848 case MODULE_OFFSET_MAP: {
2849 // Additional remapping information.
2850 const unsigned char *Data = (const unsigned char*)Blob.data();
2851 const unsigned char *DataEnd = Data + Blob.size();
2852
2853 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
2854 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
2855 F.SLocRemap.insert(std::make_pair(0U, 0));
2856 F.SLocRemap.insert(std::make_pair(2U, 1));
2857 }
2858
2859 // Continuous range maps we may be updating in our module.
2860 typedef ContinuousRangeMap<uint32_t, int, 2>::Builder
2861 RemapBuilder;
2862 RemapBuilder SLocRemap(F.SLocRemap);
2863 RemapBuilder IdentifierRemap(F.IdentifierRemap);
2864 RemapBuilder MacroRemap(F.MacroRemap);
2865 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2866 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
2867 RemapBuilder SelectorRemap(F.SelectorRemap);
2868 RemapBuilder DeclRemap(F.DeclRemap);
2869 RemapBuilder TypeRemap(F.TypeRemap);
2870
2871 while (Data < DataEnd) {
2872 using namespace llvm::support;
2873 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
2874 StringRef Name = StringRef((const char*)Data, Len);
2875 Data += Len;
2876 ModuleFile *OM = ModuleMgr.lookup(Name);
2877 if (!OM) {
2878 Error("SourceLocation remap refers to unknown module");
2879 return Failure;
2880 }
2881
2882 uint32_t SLocOffset =
2883 endian::readNext<uint32_t, little, unaligned>(Data);
2884 uint32_t IdentifierIDOffset =
2885 endian::readNext<uint32_t, little, unaligned>(Data);
2886 uint32_t MacroIDOffset =
2887 endian::readNext<uint32_t, little, unaligned>(Data);
2888 uint32_t PreprocessedEntityIDOffset =
2889 endian::readNext<uint32_t, little, unaligned>(Data);
2890 uint32_t SubmoduleIDOffset =
2891 endian::readNext<uint32_t, little, unaligned>(Data);
2892 uint32_t SelectorIDOffset =
2893 endian::readNext<uint32_t, little, unaligned>(Data);
2894 uint32_t DeclIDOffset =
2895 endian::readNext<uint32_t, little, unaligned>(Data);
2896 uint32_t TypeIndexOffset =
2897 endian::readNext<uint32_t, little, unaligned>(Data);
2898
2899 uint32_t None = std::numeric_limits<uint32_t>::max();
2900
2901 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
2902 RemapBuilder &Remap) {
2903 if (Offset != None)
2904 Remap.insert(std::make_pair(Offset,
2905 static_cast<int>(BaseOffset - Offset)));
2906 };
2907 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
2908 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
2909 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
2910 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
2911 PreprocessedEntityRemap);
2912 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
2913 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
2914 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
2915 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
2916
2917 // Global -> local mappings.
2918 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
2919 }
2920 break;
2921 }
2922
2923 case SOURCE_MANAGER_LINE_TABLE:
2924 if (ParseLineTable(F, Record))
2925 return Failure;
2926 break;
2927
2928 case SOURCE_LOCATION_PRELOADS: {
2929 // Need to transform from the local view (1-based IDs) to the global view,
2930 // which is based off F.SLocEntryBaseID.
2931 if (!F.PreloadSLocEntries.empty()) {
2932 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
2933 return Failure;
2934 }
2935
2936 F.PreloadSLocEntries.swap(Record);
2937 break;
2938 }
2939
2940 case EXT_VECTOR_DECLS:
2941 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2942 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2943 break;
2944
2945 case VTABLE_USES:
2946 if (Record.size() % 3 != 0) {
2947 Error("Invalid VTABLE_USES record");
2948 return Failure;
2949 }
2950
2951 // Later tables overwrite earlier ones.
2952 // FIXME: Modules will have some trouble with this. This is clearly not
2953 // the right way to do this.
2954 VTableUses.clear();
2955
2956 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2957 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2958 VTableUses.push_back(
2959 ReadSourceLocation(F, Record, Idx).getRawEncoding());
2960 VTableUses.push_back(Record[Idx++]);
2961 }
2962 break;
2963
2964 case PENDING_IMPLICIT_INSTANTIATIONS:
2965 if (PendingInstantiations.size() % 2 != 0) {
2966 Error("Invalid existing PendingInstantiations");
2967 return Failure;
2968 }
2969
2970 if (Record.size() % 2 != 0) {
2971 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
2972 return Failure;
2973 }
2974
2975 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2976 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2977 PendingInstantiations.push_back(
2978 ReadSourceLocation(F, Record, I).getRawEncoding());
2979 }
2980 break;
2981
2982 case SEMA_DECL_REFS:
2983 if (Record.size() != 2) {
2984 Error("Invalid SEMA_DECL_REFS block");
2985 return Failure;
2986 }
2987 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2988 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2989 break;
2990
2991 case PPD_ENTITIES_OFFSETS: {
2992 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
2993 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
2994 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
2995
2996 unsigned LocalBasePreprocessedEntityID = Record[0];
2997
2998 unsigned StartingID;
2999 if (!PP.getPreprocessingRecord())
3000 PP.createPreprocessingRecord();
3001 if (!PP.getPreprocessingRecord()->getExternalSource())
3002 PP.getPreprocessingRecord()->SetExternalSource(*this);
3003 StartingID
3004 = PP.getPreprocessingRecord()
3005 ->allocateLoadedEntities(F.NumPreprocessedEntities);
3006 F.BasePreprocessedEntityID = StartingID;
3007
3008 if (F.NumPreprocessedEntities > 0) {
3009 // Introduce the global -> local mapping for preprocessed entities in
3010 // this module.
3011 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3012
3013 // Introduce the local -> global mapping for preprocessed entities in
3014 // this module.
3015 F.PreprocessedEntityRemap.insertOrReplace(
3016 std::make_pair(LocalBasePreprocessedEntityID,
3017 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3018 }
3019
3020 break;
3021 }
3022
3023 case DECL_UPDATE_OFFSETS: {
3024 if (Record.size() % 2 != 0) {
3025 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
3026 return Failure;
3027 }
3028 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3029 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3030 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3031
3032 // If we've already loaded the decl, perform the updates when we finish
3033 // loading this block.
3034 if (Decl *D = GetExistingDecl(ID))
3035 PendingUpdateRecords.push_back(std::make_pair(ID, D));
3036 }
3037 break;
3038 }
3039
3040 case OBJC_CATEGORIES_MAP: {
3041 if (F.LocalNumObjCCategoriesInMap != 0) {
3042 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
3043 return Failure;
3044 }
3045
3046 F.LocalNumObjCCategoriesInMap = Record[0];
3047 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
3048 break;
3049 }
3050
3051 case OBJC_CATEGORIES:
3052 F.ObjCCategories.swap(Record);
3053 break;
3054
3055 case DIAG_PRAGMA_MAPPINGS:
3056 if (F.PragmaDiagMappings.empty())
3057 F.PragmaDiagMappings.swap(Record);
3058 else
3059 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
3060 Record.begin(), Record.end());
3061 break;
3062
3063 case CUDA_SPECIAL_DECL_REFS:
3064 // Later tables overwrite earlier ones.
3065 // FIXME: Modules will have trouble with this.
3066 CUDASpecialDeclRefs.clear();
3067 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3068 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3069 break;
3070
3071 case HEADER_SEARCH_TABLE: {
3072 F.HeaderFileInfoTableData = Blob.data();
3073 F.LocalNumHeaderFileInfos = Record[1];
3074 if (Record[0]) {
3075 F.HeaderFileInfoTable
3076 = HeaderFileInfoLookupTable::Create(
3077 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3078 (const unsigned char *)F.HeaderFileInfoTableData,
3079 HeaderFileInfoTrait(*this, F,
3080 &PP.getHeaderSearchInfo(),
3081 Blob.data() + Record[2]));
3082
3083 PP.getHeaderSearchInfo().SetExternalSource(this);
3084 if (!PP.getHeaderSearchInfo().getExternalLookup())
3085 PP.getHeaderSearchInfo().SetExternalLookup(this);
3086 }
3087 break;
3088 }
3089
3090 case FP_PRAGMA_OPTIONS:
3091 // Later tables overwrite earlier ones.
3092 FPPragmaOptions.swap(Record);
3093 break;
3094
3095 case OPENCL_EXTENSIONS:
3096 // Later tables overwrite earlier ones.
3097 OpenCLExtensions.swap(Record);
3098 break;
3099
3100 case TENTATIVE_DEFINITIONS:
3101 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3102 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3103 break;
3104
3105 case KNOWN_NAMESPACES:
3106 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3107 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3108 break;
3109
3110 case UNDEFINED_BUT_USED:
3111 if (UndefinedButUsed.size() % 2 != 0) {
3112 Error("Invalid existing UndefinedButUsed");
3113 return Failure;
3114 }
3115
3116 if (Record.size() % 2 != 0) {
3117 Error("invalid undefined-but-used record");
3118 return Failure;
3119 }
3120 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
3121 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3122 UndefinedButUsed.push_back(
3123 ReadSourceLocation(F, Record, I).getRawEncoding());
3124 }
3125 break;
3126 case DELETE_EXPRS_TO_ANALYZE:
3127 for (unsigned I = 0, N = Record.size(); I != N;) {
3128 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3129 const uint64_t Count = Record[I++];
3130 DelayedDeleteExprs.push_back(Count);
3131 for (uint64_t C = 0; C < Count; ++C) {
3132 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3133 bool IsArrayForm = Record[I++] == 1;
3134 DelayedDeleteExprs.push_back(IsArrayForm);
3135 }
3136 }
3137 break;
3138
3139 case IMPORTED_MODULES: {
3140 if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) {
3141 // If we aren't loading a module (which has its own exports), make
3142 // all of the imported modules visible.
3143 // FIXME: Deal with macros-only imports.
3144 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3145 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3146 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3147 if (GlobalID)
3148 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
3149 }
3150 }
3151 break;
3152 }
3153
3154 case MACRO_OFFSET: {
3155 if (F.LocalNumMacros != 0) {
3156 Error("duplicate MACRO_OFFSET record in AST file");
3157 return Failure;
3158 }
3159 F.MacroOffsets = (const uint32_t *)Blob.data();
3160 F.LocalNumMacros = Record[0];
3161 unsigned LocalBaseMacroID = Record[1];
3162 F.BaseMacroID = getTotalNumMacros();
3163
3164 if (F.LocalNumMacros > 0) {
3165 // Introduce the global -> local mapping for macros within this module.
3166 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3167
3168 // Introduce the local -> global mapping for macros within this module.
3169 F.MacroRemap.insertOrReplace(
3170 std::make_pair(LocalBaseMacroID,
3171 F.BaseMacroID - LocalBaseMacroID));
3172
3173 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
3174 }
3175 break;
3176 }
3177
3178 case LATE_PARSED_TEMPLATE: {
3179 LateParsedTemplates.append(Record.begin(), Record.end());
3180 break;
3181 }
3182
3183 case OPTIMIZE_PRAGMA_OPTIONS:
3184 if (Record.size() != 1) {
3185 Error("invalid pragma optimize record");
3186 return Failure;
3187 }
3188 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3189 break;
3190
3191 case MSSTRUCT_PRAGMA_OPTIONS:
3192 if (Record.size() != 1) {
3193 Error("invalid pragma ms_struct record");
3194 return Failure;
3195 }
3196 PragmaMSStructState = Record[0];
3197 break;
3198
3199 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3200 if (Record.size() != 2) {
3201 Error("invalid pragma ms_struct record");
3202 return Failure;
3203 }
3204 PragmaMSPointersToMembersState = Record[0];
3205 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3206 break;
3207
3208 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3209 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3210 UnusedLocalTypedefNameCandidates.push_back(
3211 getGlobalDeclID(F, Record[I]));
3212 break;
3213 }
3214 }
3215 }
3216
3217 ASTReader::ASTReadResult
ReadModuleMapFileBlock(RecordData & Record,ModuleFile & F,const ModuleFile * ImportedBy,unsigned ClientLoadCapabilities)3218 ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3219 const ModuleFile *ImportedBy,
3220 unsigned ClientLoadCapabilities) {
3221 unsigned Idx = 0;
3222 F.ModuleMapPath = ReadPath(F, Record, Idx);
3223
3224 if (F.Kind == MK_ExplicitModule) {
3225 // For an explicitly-loaded module, we don't care whether the original
3226 // module map file exists or matches.
3227 return Success;
3228 }
3229
3230 // Try to resolve ModuleName in the current header search context and
3231 // verify that it is found in the same module map file as we saved. If the
3232 // top-level AST file is a main file, skip this check because there is no
3233 // usable header search context.
3234 assert(!F.ModuleName.empty() &&
3235 "MODULE_NAME should come before MODULE_MAP_FILE");
3236 if (F.Kind == MK_ImplicitModule &&
3237 (*ModuleMgr.begin())->Kind != MK_MainFile) {
3238 // An implicitly-loaded module file should have its module listed in some
3239 // module map file that we've already loaded.
3240 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
3241 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3242 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3243 if (!ModMap) {
3244 assert(ImportedBy && "top-level import should be verified");
3245 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3246 if (auto *ASTFE = M ? M->getASTFile() : nullptr)
3247 // This module was defined by an imported (explicit) module.
3248 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3249 << ASTFE->getName();
3250 else
3251 // This module was built with a different module map.
3252 Diag(diag::err_imported_module_not_found)
3253 << F.ModuleName << F.FileName << ImportedBy->FileName
3254 << F.ModuleMapPath;
3255 }
3256 return OutOfDate;
3257 }
3258
3259 assert(M->Name == F.ModuleName && "found module with different name");
3260
3261 // Check the primary module map file.
3262 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
3263 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3264 assert(ModMap && "found module is missing module map file");
3265 assert(ImportedBy && "top-level import should be verified");
3266 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3267 Diag(diag::err_imported_module_modmap_changed)
3268 << F.ModuleName << ImportedBy->FileName
3269 << ModMap->getName() << F.ModuleMapPath;
3270 return OutOfDate;
3271 }
3272
3273 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3274 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3275 // FIXME: we should use input files rather than storing names.
3276 std::string Filename = ReadPath(F, Record, Idx);
3277 const FileEntry *F =
3278 FileMgr.getFile(Filename, false, false);
3279 if (F == nullptr) {
3280 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3281 Error("could not find file '" + Filename +"' referenced by AST file");
3282 return OutOfDate;
3283 }
3284 AdditionalStoredMaps.insert(F);
3285 }
3286
3287 // Check any additional module map files (e.g. module.private.modulemap)
3288 // that are not in the pcm.
3289 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3290 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3291 // Remove files that match
3292 // Note: SmallPtrSet::erase is really remove
3293 if (!AdditionalStoredMaps.erase(ModMap)) {
3294 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3295 Diag(diag::err_module_different_modmap)
3296 << F.ModuleName << /*new*/0 << ModMap->getName();
3297 return OutOfDate;
3298 }
3299 }
3300 }
3301
3302 // Check any additional module map files that are in the pcm, but not
3303 // found in header search. Cases that match are already removed.
3304 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3305 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3306 Diag(diag::err_module_different_modmap)
3307 << F.ModuleName << /*not new*/1 << ModMap->getName();
3308 return OutOfDate;
3309 }
3310 }
3311
3312 if (Listener)
3313 Listener->ReadModuleMapFile(F.ModuleMapPath);
3314 return Success;
3315 }
3316
3317
3318 /// \brief Move the given method to the back of the global list of methods.
moveMethodToBackOfGlobalList(Sema & S,ObjCMethodDecl * Method)3319 static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3320 // Find the entry for this selector in the method pool.
3321 Sema::GlobalMethodPool::iterator Known
3322 = S.MethodPool.find(Method->getSelector());
3323 if (Known == S.MethodPool.end())
3324 return;
3325
3326 // Retrieve the appropriate method list.
3327 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3328 : Known->second.second;
3329 bool Found = false;
3330 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
3331 if (!Found) {
3332 if (List->getMethod() == Method) {
3333 Found = true;
3334 } else {
3335 // Keep searching.
3336 continue;
3337 }
3338 }
3339
3340 if (List->getNext())
3341 List->setMethod(List->getNext()->getMethod());
3342 else
3343 List->setMethod(Method);
3344 }
3345 }
3346
makeNamesVisible(const HiddenNames & Names,Module * Owner)3347 void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
3348 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
3349 for (Decl *D : Names) {
3350 bool wasHidden = D->Hidden;
3351 D->Hidden = false;
3352
3353 if (wasHidden && SemaObj) {
3354 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3355 moveMethodToBackOfGlobalList(*SemaObj, Method);
3356 }
3357 }
3358 }
3359 }
3360
makeModuleVisible(Module * Mod,Module::NameVisibilityKind NameVisibility,SourceLocation ImportLoc)3361 void ASTReader::makeModuleVisible(Module *Mod,
3362 Module::NameVisibilityKind NameVisibility,
3363 SourceLocation ImportLoc) {
3364 llvm::SmallPtrSet<Module *, 4> Visited;
3365 SmallVector<Module *, 4> Stack;
3366 Stack.push_back(Mod);
3367 while (!Stack.empty()) {
3368 Mod = Stack.pop_back_val();
3369
3370 if (NameVisibility <= Mod->NameVisibility) {
3371 // This module already has this level of visibility (or greater), so
3372 // there is nothing more to do.
3373 continue;
3374 }
3375
3376 if (!Mod->isAvailable()) {
3377 // Modules that aren't available cannot be made visible.
3378 continue;
3379 }
3380
3381 // Update the module's name visibility.
3382 Mod->NameVisibility = NameVisibility;
3383
3384 // If we've already deserialized any names from this module,
3385 // mark them as visible.
3386 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3387 if (Hidden != HiddenNamesMap.end()) {
3388 auto HiddenNames = std::move(*Hidden);
3389 HiddenNamesMap.erase(Hidden);
3390 makeNamesVisible(HiddenNames.second, HiddenNames.first);
3391 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3392 "making names visible added hidden names");
3393 }
3394
3395 // Push any exported modules onto the stack to be marked as visible.
3396 SmallVector<Module *, 16> Exports;
3397 Mod->getExportedModules(Exports);
3398 for (SmallVectorImpl<Module *>::iterator
3399 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3400 Module *Exported = *I;
3401 if (Visited.insert(Exported).second)
3402 Stack.push_back(Exported);
3403 }
3404 }
3405 }
3406
loadGlobalIndex()3407 bool ASTReader::loadGlobalIndex() {
3408 if (GlobalIndex)
3409 return false;
3410
3411 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3412 !Context.getLangOpts().Modules)
3413 return true;
3414
3415 // Try to load the global index.
3416 TriedLoadingGlobalIndex = true;
3417 StringRef ModuleCachePath
3418 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3419 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
3420 = GlobalModuleIndex::readIndex(ModuleCachePath);
3421 if (!Result.first)
3422 return true;
3423
3424 GlobalIndex.reset(Result.first);
3425 ModuleMgr.setGlobalIndex(GlobalIndex.get());
3426 return false;
3427 }
3428
isGlobalIndexUnavailable() const3429 bool ASTReader::isGlobalIndexUnavailable() const {
3430 return Context.getLangOpts().Modules && UseGlobalIndex &&
3431 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3432 }
3433
updateModuleTimestamp(ModuleFile & MF)3434 static void updateModuleTimestamp(ModuleFile &MF) {
3435 // Overwrite the timestamp file contents so that file's mtime changes.
3436 std::string TimestampFilename = MF.getTimestampFilename();
3437 std::error_code EC;
3438 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3439 if (EC)
3440 return;
3441 OS << "Timestamp file\n";
3442 }
3443
3444 /// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3445 /// cursor into the start of the given block ID, returning false on success and
3446 /// true on failure.
SkipCursorToBlock(BitstreamCursor & Cursor,unsigned BlockID)3447 static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3448 while (1) {
3449 llvm::BitstreamEntry Entry = Cursor.advance();
3450 switch (Entry.Kind) {
3451 case llvm::BitstreamEntry::Error:
3452 case llvm::BitstreamEntry::EndBlock:
3453 return true;
3454
3455 case llvm::BitstreamEntry::Record:
3456 // Ignore top-level records.
3457 Cursor.skipRecord(Entry.ID);
3458 break;
3459
3460 case llvm::BitstreamEntry::SubBlock:
3461 if (Entry.ID == BlockID) {
3462 if (Cursor.EnterSubBlock(BlockID))
3463 return true;
3464 // Found it!
3465 return false;
3466 }
3467
3468 if (Cursor.SkipBlock())
3469 return true;
3470 }
3471 }
3472 }
3473
ReadAST(StringRef FileName,ModuleKind Type,SourceLocation ImportLoc,unsigned ClientLoadCapabilities)3474 ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
3475 ModuleKind Type,
3476 SourceLocation ImportLoc,
3477 unsigned ClientLoadCapabilities) {
3478 llvm::SaveAndRestore<SourceLocation>
3479 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3480
3481 // Defer any pending actions until we get to the end of reading the AST file.
3482 Deserializing AnASTFile(this);
3483
3484 // Bump the generation number.
3485 unsigned PreviousGeneration = incrementGeneration(Context);
3486
3487 unsigned NumModules = ModuleMgr.size();
3488 SmallVector<ImportedModule, 4> Loaded;
3489 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
3490 /*ImportedBy=*/nullptr, Loaded,
3491 0, 0, 0,
3492 ClientLoadCapabilities)) {
3493 case Failure:
3494 case Missing:
3495 case OutOfDate:
3496 case VersionMismatch:
3497 case ConfigurationMismatch:
3498 case HadErrors: {
3499 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3500 for (const ImportedModule &IM : Loaded)
3501 LoadedSet.insert(IM.Mod);
3502
3503 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
3504 LoadedSet,
3505 Context.getLangOpts().Modules
3506 ? &PP.getHeaderSearchInfo().getModuleMap()
3507 : nullptr);
3508
3509 // If we find that any modules are unusable, the global index is going
3510 // to be out-of-date. Just remove it.
3511 GlobalIndex.reset();
3512 ModuleMgr.setGlobalIndex(nullptr);
3513 return ReadResult;
3514 }
3515 case Success:
3516 break;
3517 }
3518
3519 // Here comes stuff that we only do once the entire chain is loaded.
3520
3521 // Load the AST blocks of all of the modules that we loaded.
3522 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3523 MEnd = Loaded.end();
3524 M != MEnd; ++M) {
3525 ModuleFile &F = *M->Mod;
3526
3527 // Read the AST block.
3528 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3529 return Result;
3530
3531 // Read the extension blocks.
3532 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3533 if (ASTReadResult Result = ReadExtensionBlock(F))
3534 return Result;
3535 }
3536
3537 // Once read, set the ModuleFile bit base offset and update the size in
3538 // bits of all files we've seen.
3539 F.GlobalBitOffset = TotalModulesSizeInBits;
3540 TotalModulesSizeInBits += F.SizeInBits;
3541 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3542
3543 // Preload SLocEntries.
3544 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3545 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3546 // Load it through the SourceManager and don't call ReadSLocEntry()
3547 // directly because the entry may have already been loaded in which case
3548 // calling ReadSLocEntry() directly would trigger an assertion in
3549 // SourceManager.
3550 SourceMgr.getLoadedSLocEntryByID(Index);
3551 }
3552
3553 // Preload all the pending interesting identifiers by marking them out of
3554 // date.
3555 for (auto Offset : F.PreloadIdentifierOffsets) {
3556 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3557 F.IdentifierTableData + Offset);
3558
3559 ASTIdentifierLookupTrait Trait(*this, F);
3560 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3561 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
3562 auto &II = PP.getIdentifierTable().getOwn(Key);
3563 II.setOutOfDate(true);
3564
3565 // Mark this identifier as being from an AST file so that we can track
3566 // whether we need to serialize it.
3567 markIdentifierFromAST(*this, II);
3568
3569 // Associate the ID with the identifier so that the writer can reuse it.
3570 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3571 SetIdentifierInfo(ID, &II);
3572 }
3573 }
3574
3575 // Setup the import locations and notify the module manager that we've
3576 // committed to these module files.
3577 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3578 MEnd = Loaded.end();
3579 M != MEnd; ++M) {
3580 ModuleFile &F = *M->Mod;
3581
3582 ModuleMgr.moduleFileAccepted(&F);
3583
3584 // Set the import location.
3585 F.DirectImportLoc = ImportLoc;
3586 // FIXME: We assume that locations from PCH / preamble do not need
3587 // any translation.
3588 if (!M->ImportedBy)
3589 F.ImportLoc = M->ImportLoc;
3590 else
3591 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
3592 }
3593
3594 if (!Context.getLangOpts().CPlusPlus ||
3595 (Type != MK_ImplicitModule && Type != MK_ExplicitModule)) {
3596 // Mark all of the identifiers in the identifier table as being out of date,
3597 // so that various accessors know to check the loaded modules when the
3598 // identifier is used.
3599 //
3600 // For C++ modules, we don't need information on many identifiers (just
3601 // those that provide macros or are poisoned), so we mark all of
3602 // the interesting ones via PreloadIdentifierOffsets.
3603 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3604 IdEnd = PP.getIdentifierTable().end();
3605 Id != IdEnd; ++Id)
3606 Id->second->setOutOfDate(true);
3607 }
3608 // Mark selectors as out of date.
3609 for (auto Sel : SelectorGeneration)
3610 SelectorOutOfDate[Sel.first] = true;
3611
3612 // Resolve any unresolved module exports.
3613 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3614 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
3615 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3616 Module *ResolvedMod = getSubmodule(GlobalID);
3617
3618 switch (Unresolved.Kind) {
3619 case UnresolvedModuleRef::Conflict:
3620 if (ResolvedMod) {
3621 Module::Conflict Conflict;
3622 Conflict.Other = ResolvedMod;
3623 Conflict.Message = Unresolved.String.str();
3624 Unresolved.Mod->Conflicts.push_back(Conflict);
3625 }
3626 continue;
3627
3628 case UnresolvedModuleRef::Import:
3629 if (ResolvedMod)
3630 Unresolved.Mod->Imports.insert(ResolvedMod);
3631 continue;
3632
3633 case UnresolvedModuleRef::Export:
3634 if (ResolvedMod || Unresolved.IsWildcard)
3635 Unresolved.Mod->Exports.push_back(
3636 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3637 continue;
3638 }
3639 }
3640 UnresolvedModuleRefs.clear();
3641
3642 // FIXME: How do we load the 'use'd modules? They may not be submodules.
3643 // Might be unnecessary as use declarations are only used to build the
3644 // module itself.
3645
3646 InitializeContext();
3647
3648 if (SemaObj)
3649 UpdateSema();
3650
3651 if (DeserializationListener)
3652 DeserializationListener->ReaderInitialized(this);
3653
3654 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
3655 if (PrimaryModule.OriginalSourceFileID.isValid()) {
3656 PrimaryModule.OriginalSourceFileID
3657 = FileID::get(PrimaryModule.SLocEntryBaseID
3658 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
3659
3660 // If this AST file is a precompiled preamble, then set the
3661 // preamble file ID of the source manager to the file source file
3662 // from which the preamble was built.
3663 if (Type == MK_Preamble) {
3664 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3665 } else if (Type == MK_MainFile) {
3666 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3667 }
3668 }
3669
3670 // For any Objective-C class definitions we have already loaded, make sure
3671 // that we load any additional categories.
3672 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3673 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3674 ObjCClassesLoaded[I],
3675 PreviousGeneration);
3676 }
3677
3678 if (PP.getHeaderSearchInfo()
3679 .getHeaderSearchOpts()
3680 .ModulesValidateOncePerBuildSession) {
3681 // Now we are certain that the module and all modules it depends on are
3682 // up to date. Create or update timestamp files for modules that are
3683 // located in the module cache (not for PCH files that could be anywhere
3684 // in the filesystem).
3685 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3686 ImportedModule &M = Loaded[I];
3687 if (M.Mod->Kind == MK_ImplicitModule) {
3688 updateModuleTimestamp(*M.Mod);
3689 }
3690 }
3691 }
3692
3693 return Success;
3694 }
3695
3696 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile);
3697
3698 /// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
startsWithASTFileMagic(BitstreamCursor & Stream)3699 static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
3700 return Stream.Read(8) == 'C' &&
3701 Stream.Read(8) == 'P' &&
3702 Stream.Read(8) == 'C' &&
3703 Stream.Read(8) == 'H';
3704 }
3705
moduleKindForDiagnostic(ModuleKind Kind)3706 static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
3707 switch (Kind) {
3708 case MK_PCH:
3709 return 0; // PCH
3710 case MK_ImplicitModule:
3711 case MK_ExplicitModule:
3712 return 1; // module
3713 case MK_MainFile:
3714 case MK_Preamble:
3715 return 2; // main source file
3716 }
3717 llvm_unreachable("unknown module kind");
3718 }
3719
3720 ASTReader::ASTReadResult
ReadASTCore(StringRef FileName,ModuleKind Type,SourceLocation ImportLoc,ModuleFile * ImportedBy,SmallVectorImpl<ImportedModule> & Loaded,off_t ExpectedSize,time_t ExpectedModTime,ASTFileSignature ExpectedSignature,unsigned ClientLoadCapabilities)3721 ASTReader::ReadASTCore(StringRef FileName,
3722 ModuleKind Type,
3723 SourceLocation ImportLoc,
3724 ModuleFile *ImportedBy,
3725 SmallVectorImpl<ImportedModule> &Loaded,
3726 off_t ExpectedSize, time_t ExpectedModTime,
3727 ASTFileSignature ExpectedSignature,
3728 unsigned ClientLoadCapabilities) {
3729 ModuleFile *M;
3730 std::string ErrorStr;
3731 ModuleManager::AddModuleResult AddResult
3732 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
3733 getGeneration(), ExpectedSize, ExpectedModTime,
3734 ExpectedSignature, readASTFileSignature,
3735 M, ErrorStr);
3736
3737 switch (AddResult) {
3738 case ModuleManager::AlreadyLoaded:
3739 return Success;
3740
3741 case ModuleManager::NewlyLoaded:
3742 // Load module file below.
3743 break;
3744
3745 case ModuleManager::Missing:
3746 // The module file was missing; if the client can handle that, return
3747 // it.
3748 if (ClientLoadCapabilities & ARR_Missing)
3749 return Missing;
3750
3751 // Otherwise, return an error.
3752 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
3753 << FileName << ErrorStr.empty()
3754 << ErrorStr;
3755 return Failure;
3756
3757 case ModuleManager::OutOfDate:
3758 // We couldn't load the module file because it is out-of-date. If the
3759 // client can handle out-of-date, return it.
3760 if (ClientLoadCapabilities & ARR_OutOfDate)
3761 return OutOfDate;
3762
3763 // Otherwise, return an error.
3764 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
3765 << FileName << ErrorStr.empty()
3766 << ErrorStr;
3767 return Failure;
3768 }
3769
3770 assert(M && "Missing module file");
3771
3772 // FIXME: This seems rather a hack. Should CurrentDir be part of the
3773 // module?
3774 if (FileName != "-") {
3775 CurrentDir = llvm::sys::path::parent_path(FileName);
3776 if (CurrentDir.empty()) CurrentDir = ".";
3777 }
3778
3779 ModuleFile &F = *M;
3780 BitstreamCursor &Stream = F.Stream;
3781 PCHContainerRdr.ExtractPCH(F.Buffer->getMemBufferRef(), F.StreamFile);
3782 Stream.init(&F.StreamFile);
3783 F.SizeInBits = F.Buffer->getBufferSize() * 8;
3784
3785 // Sniff for the signature.
3786 if (!startsWithASTFileMagic(Stream)) {
3787 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
3788 << FileName;
3789 return Failure;
3790 }
3791
3792 // This is used for compatibility with older PCH formats.
3793 bool HaveReadControlBlock = false;
3794 while (1) {
3795 llvm::BitstreamEntry Entry = Stream.advance();
3796
3797 switch (Entry.Kind) {
3798 case llvm::BitstreamEntry::Error:
3799 case llvm::BitstreamEntry::Record:
3800 case llvm::BitstreamEntry::EndBlock:
3801 Error("invalid record at top-level of AST file");
3802 return Failure;
3803
3804 case llvm::BitstreamEntry::SubBlock:
3805 break;
3806 }
3807
3808 switch (Entry.ID) {
3809 case CONTROL_BLOCK_ID:
3810 HaveReadControlBlock = true;
3811 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
3812 case Success:
3813 // Check that we didn't try to load a non-module AST file as a module.
3814 //
3815 // FIXME: Should we also perform the converse check? Loading a module as
3816 // a PCH file sort of works, but it's a bit wonky.
3817 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule) &&
3818 F.ModuleName.empty()) {
3819 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
3820 if (Result != OutOfDate ||
3821 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
3822 Diag(diag::err_module_file_not_module) << FileName;
3823 return Result;
3824 }
3825 break;
3826
3827 case Failure: return Failure;
3828 case Missing: return Missing;
3829 case OutOfDate: return OutOfDate;
3830 case VersionMismatch: return VersionMismatch;
3831 case ConfigurationMismatch: return ConfigurationMismatch;
3832 case HadErrors: return HadErrors;
3833 }
3834 break;
3835
3836 case AST_BLOCK_ID:
3837 if (!HaveReadControlBlock) {
3838 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
3839 Diag(diag::err_pch_version_too_old);
3840 return VersionMismatch;
3841 }
3842
3843 // Record that we've loaded this module.
3844 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
3845 return Success;
3846
3847 default:
3848 if (Stream.SkipBlock()) {
3849 Error("malformed block record in AST file");
3850 return Failure;
3851 }
3852 break;
3853 }
3854 }
3855
3856 return Success;
3857 }
3858
3859 /// Parse a record and blob containing module file extension metadata.
parseModuleFileExtensionMetadata(const SmallVectorImpl<uint64_t> & Record,StringRef Blob,ModuleFileExtensionMetadata & Metadata)3860 static bool parseModuleFileExtensionMetadata(
3861 const SmallVectorImpl<uint64_t> &Record,
3862 StringRef Blob,
3863 ModuleFileExtensionMetadata &Metadata) {
3864 if (Record.size() < 4) return true;
3865
3866 Metadata.MajorVersion = Record[0];
3867 Metadata.MinorVersion = Record[1];
3868
3869 unsigned BlockNameLen = Record[2];
3870 unsigned UserInfoLen = Record[3];
3871
3872 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
3873
3874 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
3875 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
3876 Blob.data() + BlockNameLen + UserInfoLen);
3877 return false;
3878 }
3879
ReadExtensionBlock(ModuleFile & F)3880 ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
3881 BitstreamCursor &Stream = F.Stream;
3882
3883 RecordData Record;
3884 while (true) {
3885 llvm::BitstreamEntry Entry = Stream.advance();
3886 switch (Entry.Kind) {
3887 case llvm::BitstreamEntry::SubBlock:
3888 if (Stream.SkipBlock())
3889 return Failure;
3890
3891 continue;
3892
3893 case llvm::BitstreamEntry::EndBlock:
3894 return Success;
3895
3896 case llvm::BitstreamEntry::Error:
3897 return HadErrors;
3898
3899 case llvm::BitstreamEntry::Record:
3900 break;
3901 }
3902
3903 Record.clear();
3904 StringRef Blob;
3905 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
3906 switch (RecCode) {
3907 case EXTENSION_METADATA: {
3908 ModuleFileExtensionMetadata Metadata;
3909 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
3910 return Failure;
3911
3912 // Find a module file extension with this block name.
3913 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
3914 if (Known == ModuleFileExtensions.end()) break;
3915
3916 // Form a reader.
3917 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
3918 F, Stream)) {
3919 F.ExtensionReaders.push_back(std::move(Reader));
3920 }
3921
3922 break;
3923 }
3924 }
3925 }
3926
3927 return Success;
3928 }
3929
InitializeContext()3930 void ASTReader::InitializeContext() {
3931 // If there's a listener, notify them that we "read" the translation unit.
3932 if (DeserializationListener)
3933 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
3934 Context.getTranslationUnitDecl());
3935
3936 // FIXME: Find a better way to deal with collisions between these
3937 // built-in types. Right now, we just ignore the problem.
3938
3939 // Load the special types.
3940 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
3941 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3942 if (!Context.CFConstantStringTypeDecl)
3943 Context.setCFConstantStringType(GetType(String));
3944 }
3945
3946 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3947 QualType FileType = GetType(File);
3948 if (FileType.isNull()) {
3949 Error("FILE type is NULL");
3950 return;
3951 }
3952
3953 if (!Context.FILEDecl) {
3954 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3955 Context.setFILEDecl(Typedef->getDecl());
3956 else {
3957 const TagType *Tag = FileType->getAs<TagType>();
3958 if (!Tag) {
3959 Error("Invalid FILE type in AST file");
3960 return;
3961 }
3962 Context.setFILEDecl(Tag->getDecl());
3963 }
3964 }
3965 }
3966
3967 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
3968 QualType Jmp_bufType = GetType(Jmp_buf);
3969 if (Jmp_bufType.isNull()) {
3970 Error("jmp_buf type is NULL");
3971 return;
3972 }
3973
3974 if (!Context.jmp_bufDecl) {
3975 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3976 Context.setjmp_bufDecl(Typedef->getDecl());
3977 else {
3978 const TagType *Tag = Jmp_bufType->getAs<TagType>();
3979 if (!Tag) {
3980 Error("Invalid jmp_buf type in AST file");
3981 return;
3982 }
3983 Context.setjmp_bufDecl(Tag->getDecl());
3984 }
3985 }
3986 }
3987
3988 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
3989 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
3990 if (Sigjmp_bufType.isNull()) {
3991 Error("sigjmp_buf type is NULL");
3992 return;
3993 }
3994
3995 if (!Context.sigjmp_bufDecl) {
3996 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
3997 Context.setsigjmp_bufDecl(Typedef->getDecl());
3998 else {
3999 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4000 assert(Tag && "Invalid sigjmp_buf type in AST file");
4001 Context.setsigjmp_bufDecl(Tag->getDecl());
4002 }
4003 }
4004 }
4005
4006 if (unsigned ObjCIdRedef
4007 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4008 if (Context.ObjCIdRedefinitionType.isNull())
4009 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4010 }
4011
4012 if (unsigned ObjCClassRedef
4013 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4014 if (Context.ObjCClassRedefinitionType.isNull())
4015 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4016 }
4017
4018 if (unsigned ObjCSelRedef
4019 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4020 if (Context.ObjCSelRedefinitionType.isNull())
4021 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4022 }
4023
4024 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4025 QualType Ucontext_tType = GetType(Ucontext_t);
4026 if (Ucontext_tType.isNull()) {
4027 Error("ucontext_t type is NULL");
4028 return;
4029 }
4030
4031 if (!Context.ucontext_tDecl) {
4032 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4033 Context.setucontext_tDecl(Typedef->getDecl());
4034 else {
4035 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4036 assert(Tag && "Invalid ucontext_t type in AST file");
4037 Context.setucontext_tDecl(Tag->getDecl());
4038 }
4039 }
4040 }
4041 }
4042
4043 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4044
4045 // If there were any CUDA special declarations, deserialize them.
4046 if (!CUDASpecialDeclRefs.empty()) {
4047 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4048 Context.setcudaConfigureCallDecl(
4049 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4050 }
4051
4052 // Re-export any modules that were imported by a non-module AST file.
4053 // FIXME: This does not make macro-only imports visible again.
4054 for (auto &Import : ImportedModules) {
4055 if (Module *Imported = getSubmodule(Import.ID)) {
4056 makeModuleVisible(Imported, Module::AllVisible,
4057 /*ImportLoc=*/Import.ImportLoc);
4058 if (Import.ImportLoc.isValid())
4059 PP.makeModuleVisible(Imported, Import.ImportLoc);
4060 // FIXME: should we tell Sema to make the module visible too?
4061 }
4062 }
4063 ImportedModules.clear();
4064 }
4065
finalizeForWriting()4066 void ASTReader::finalizeForWriting() {
4067 // Nothing to do for now.
4068 }
4069
4070 /// \brief Reads and return the signature record from \p StreamFile's control
4071 /// block, or else returns 0.
readASTFileSignature(llvm::BitstreamReader & StreamFile)4072 static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){
4073 BitstreamCursor Stream(StreamFile);
4074 if (!startsWithASTFileMagic(Stream))
4075 return 0;
4076
4077 // Scan for the CONTROL_BLOCK_ID block.
4078 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4079 return 0;
4080
4081 // Scan for SIGNATURE inside the control block.
4082 ASTReader::RecordData Record;
4083 while (1) {
4084 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4085 if (Entry.Kind == llvm::BitstreamEntry::EndBlock ||
4086 Entry.Kind != llvm::BitstreamEntry::Record)
4087 return 0;
4088
4089 Record.clear();
4090 StringRef Blob;
4091 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4092 return Record[0];
4093 }
4094 }
4095
4096 /// \brief Retrieve the name of the original source file name
4097 /// directly from the AST file, without actually loading the AST
4098 /// file.
getOriginalSourceFile(const std::string & ASTFileName,FileManager & FileMgr,const PCHContainerReader & PCHContainerRdr,DiagnosticsEngine & Diags)4099 std::string ASTReader::getOriginalSourceFile(
4100 const std::string &ASTFileName, FileManager &FileMgr,
4101 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
4102 // Open the AST file.
4103 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
4104 if (!Buffer) {
4105 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4106 << ASTFileName << Buffer.getError().message();
4107 return std::string();
4108 }
4109
4110 // Initialize the stream
4111 llvm::BitstreamReader StreamFile;
4112 PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
4113 BitstreamCursor Stream(StreamFile);
4114
4115 // Sniff for the signature.
4116 if (!startsWithASTFileMagic(Stream)) {
4117 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4118 return std::string();
4119 }
4120
4121 // Scan for the CONTROL_BLOCK_ID block.
4122 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
4123 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4124 return std::string();
4125 }
4126
4127 // Scan for ORIGINAL_FILE inside the control block.
4128 RecordData Record;
4129 while (1) {
4130 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4131 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4132 return std::string();
4133
4134 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4135 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4136 return std::string();
4137 }
4138
4139 Record.clear();
4140 StringRef Blob;
4141 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4142 return Blob.str();
4143 }
4144 }
4145
4146 namespace {
4147 class SimplePCHValidator : public ASTReaderListener {
4148 const LangOptions &ExistingLangOpts;
4149 const TargetOptions &ExistingTargetOpts;
4150 const PreprocessorOptions &ExistingPPOpts;
4151 std::string ExistingModuleCachePath;
4152 FileManager &FileMgr;
4153
4154 public:
SimplePCHValidator(const LangOptions & ExistingLangOpts,const TargetOptions & ExistingTargetOpts,const PreprocessorOptions & ExistingPPOpts,StringRef ExistingModuleCachePath,FileManager & FileMgr)4155 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4156 const TargetOptions &ExistingTargetOpts,
4157 const PreprocessorOptions &ExistingPPOpts,
4158 StringRef ExistingModuleCachePath,
4159 FileManager &FileMgr)
4160 : ExistingLangOpts(ExistingLangOpts),
4161 ExistingTargetOpts(ExistingTargetOpts),
4162 ExistingPPOpts(ExistingPPOpts),
4163 ExistingModuleCachePath(ExistingModuleCachePath),
4164 FileMgr(FileMgr)
4165 {
4166 }
4167
ReadLanguageOptions(const LangOptions & LangOpts,bool Complain,bool AllowCompatibleDifferences)4168 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4169 bool AllowCompatibleDifferences) override {
4170 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4171 AllowCompatibleDifferences);
4172 }
ReadTargetOptions(const TargetOptions & TargetOpts,bool Complain,bool AllowCompatibleDifferences)4173 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4174 bool AllowCompatibleDifferences) override {
4175 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4176 AllowCompatibleDifferences);
4177 }
ReadHeaderSearchOptions(const HeaderSearchOptions & HSOpts,StringRef SpecificModuleCachePath,bool Complain)4178 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4179 StringRef SpecificModuleCachePath,
4180 bool Complain) override {
4181 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4182 ExistingModuleCachePath,
4183 nullptr, ExistingLangOpts);
4184 }
ReadPreprocessorOptions(const PreprocessorOptions & PPOpts,bool Complain,std::string & SuggestedPredefines)4185 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4186 bool Complain,
4187 std::string &SuggestedPredefines) override {
4188 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
4189 SuggestedPredefines, ExistingLangOpts);
4190 }
4191 };
4192 }
4193
readASTFileControlBlock(StringRef Filename,FileManager & FileMgr,const PCHContainerReader & PCHContainerRdr,bool FindModuleFileExtensions,ASTReaderListener & Listener)4194 bool ASTReader::readASTFileControlBlock(
4195 StringRef Filename, FileManager &FileMgr,
4196 const PCHContainerReader &PCHContainerRdr,
4197 bool FindModuleFileExtensions,
4198 ASTReaderListener &Listener) {
4199 // Open the AST file.
4200 // FIXME: This allows use of the VFS; we do not allow use of the
4201 // VFS when actually loading a module.
4202 auto Buffer = FileMgr.getBufferForFile(Filename);
4203 if (!Buffer) {
4204 return true;
4205 }
4206
4207 // Initialize the stream
4208 llvm::BitstreamReader StreamFile;
4209 PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
4210 BitstreamCursor Stream(StreamFile);
4211
4212 // Sniff for the signature.
4213 if (!startsWithASTFileMagic(Stream))
4214 return true;
4215
4216 // Scan for the CONTROL_BLOCK_ID block.
4217 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4218 return true;
4219
4220 bool NeedsInputFiles = Listener.needsInputFileVisitation();
4221 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
4222 bool NeedsImports = Listener.needsImportVisitation();
4223 BitstreamCursor InputFilesCursor;
4224
4225 RecordData Record;
4226 std::string ModuleDir;
4227 bool DoneWithControlBlock = false;
4228 while (!DoneWithControlBlock) {
4229 llvm::BitstreamEntry Entry = Stream.advance();
4230
4231 switch (Entry.Kind) {
4232 case llvm::BitstreamEntry::SubBlock: {
4233 switch (Entry.ID) {
4234 case OPTIONS_BLOCK_ID: {
4235 std::string IgnoredSuggestedPredefines;
4236 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4237 /*AllowCompatibleConfigurationMismatch*/ false,
4238 Listener, IgnoredSuggestedPredefines) != Success)
4239 return true;
4240 break;
4241 }
4242
4243 case INPUT_FILES_BLOCK_ID:
4244 InputFilesCursor = Stream;
4245 if (Stream.SkipBlock() ||
4246 (NeedsInputFiles &&
4247 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4248 return true;
4249 break;
4250
4251 default:
4252 if (Stream.SkipBlock())
4253 return true;
4254 break;
4255 }
4256
4257 continue;
4258 }
4259
4260 case llvm::BitstreamEntry::EndBlock:
4261 DoneWithControlBlock = true;
4262 break;
4263
4264 case llvm::BitstreamEntry::Error:
4265 return true;
4266
4267 case llvm::BitstreamEntry::Record:
4268 break;
4269 }
4270
4271 if (DoneWithControlBlock) break;
4272
4273 Record.clear();
4274 StringRef Blob;
4275 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4276 switch ((ControlRecordTypes)RecCode) {
4277 case METADATA: {
4278 if (Record[0] != VERSION_MAJOR)
4279 return true;
4280
4281 if (Listener.ReadFullVersionInformation(Blob))
4282 return true;
4283
4284 break;
4285 }
4286 case MODULE_NAME:
4287 Listener.ReadModuleName(Blob);
4288 break;
4289 case MODULE_DIRECTORY:
4290 ModuleDir = Blob;
4291 break;
4292 case MODULE_MAP_FILE: {
4293 unsigned Idx = 0;
4294 auto Path = ReadString(Record, Idx);
4295 ResolveImportedPath(Path, ModuleDir);
4296 Listener.ReadModuleMapFile(Path);
4297 break;
4298 }
4299 case INPUT_FILE_OFFSETS: {
4300 if (!NeedsInputFiles)
4301 break;
4302
4303 unsigned NumInputFiles = Record[0];
4304 unsigned NumUserFiles = Record[1];
4305 const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
4306 for (unsigned I = 0; I != NumInputFiles; ++I) {
4307 // Go find this input file.
4308 bool isSystemFile = I >= NumUserFiles;
4309
4310 if (isSystemFile && !NeedsSystemInputFiles)
4311 break; // the rest are system input files
4312
4313 BitstreamCursor &Cursor = InputFilesCursor;
4314 SavedStreamPosition SavedPosition(Cursor);
4315 Cursor.JumpToBit(InputFileOffs[I]);
4316
4317 unsigned Code = Cursor.ReadCode();
4318 RecordData Record;
4319 StringRef Blob;
4320 bool shouldContinue = false;
4321 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4322 case INPUT_FILE:
4323 bool Overridden = static_cast<bool>(Record[3]);
4324 std::string Filename = Blob;
4325 ResolveImportedPath(Filename, ModuleDir);
4326 shouldContinue = Listener.visitInputFile(
4327 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
4328 break;
4329 }
4330 if (!shouldContinue)
4331 break;
4332 }
4333 break;
4334 }
4335
4336 case IMPORTS: {
4337 if (!NeedsImports)
4338 break;
4339
4340 unsigned Idx = 0, N = Record.size();
4341 while (Idx < N) {
4342 // Read information about the AST file.
4343 Idx += 5; // ImportLoc, Size, ModTime, Signature
4344 std::string Filename = ReadString(Record, Idx);
4345 ResolveImportedPath(Filename, ModuleDir);
4346 Listener.visitImport(Filename);
4347 }
4348 break;
4349 }
4350
4351 default:
4352 // No other validation to perform.
4353 break;
4354 }
4355 }
4356
4357 // Look for module file extension blocks, if requested.
4358 if (FindModuleFileExtensions) {
4359 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4360 bool DoneWithExtensionBlock = false;
4361 while (!DoneWithExtensionBlock) {
4362 llvm::BitstreamEntry Entry = Stream.advance();
4363
4364 switch (Entry.Kind) {
4365 case llvm::BitstreamEntry::SubBlock:
4366 if (Stream.SkipBlock())
4367 return true;
4368
4369 continue;
4370
4371 case llvm::BitstreamEntry::EndBlock:
4372 DoneWithExtensionBlock = true;
4373 continue;
4374
4375 case llvm::BitstreamEntry::Error:
4376 return true;
4377
4378 case llvm::BitstreamEntry::Record:
4379 break;
4380 }
4381
4382 Record.clear();
4383 StringRef Blob;
4384 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4385 switch (RecCode) {
4386 case EXTENSION_METADATA: {
4387 ModuleFileExtensionMetadata Metadata;
4388 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4389 return true;
4390
4391 Listener.readModuleFileExtension(Metadata);
4392 break;
4393 }
4394 }
4395 }
4396 }
4397 }
4398
4399 return false;
4400 }
4401
isAcceptableASTFile(StringRef Filename,FileManager & FileMgr,const PCHContainerReader & PCHContainerRdr,const LangOptions & LangOpts,const TargetOptions & TargetOpts,const PreprocessorOptions & PPOpts,std::string ExistingModuleCachePath)4402 bool ASTReader::isAcceptableASTFile(
4403 StringRef Filename, FileManager &FileMgr,
4404 const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts,
4405 const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts,
4406 std::string ExistingModuleCachePath) {
4407 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4408 ExistingModuleCachePath, FileMgr);
4409 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
4410 /*FindModuleFileExtensions=*/false,
4411 validator);
4412 }
4413
4414 ASTReader::ASTReadResult
ReadSubmoduleBlock(ModuleFile & F,unsigned ClientLoadCapabilities)4415 ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
4416 // Enter the submodule block.
4417 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4418 Error("malformed submodule block record in AST file");
4419 return Failure;
4420 }
4421
4422 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4423 bool First = true;
4424 Module *CurrentModule = nullptr;
4425 RecordData Record;
4426 while (true) {
4427 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4428
4429 switch (Entry.Kind) {
4430 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4431 case llvm::BitstreamEntry::Error:
4432 Error("malformed block record in AST file");
4433 return Failure;
4434 case llvm::BitstreamEntry::EndBlock:
4435 return Success;
4436 case llvm::BitstreamEntry::Record:
4437 // The interesting case.
4438 break;
4439 }
4440
4441 // Read a record.
4442 StringRef Blob;
4443 Record.clear();
4444 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4445
4446 if ((Kind == SUBMODULE_METADATA) != First) {
4447 Error("submodule metadata record should be at beginning of block");
4448 return Failure;
4449 }
4450 First = false;
4451
4452 // Submodule information is only valid if we have a current module.
4453 // FIXME: Should we error on these cases?
4454 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4455 Kind != SUBMODULE_DEFINITION)
4456 continue;
4457
4458 switch (Kind) {
4459 default: // Default behavior: ignore.
4460 break;
4461
4462 case SUBMODULE_DEFINITION: {
4463 if (Record.size() < 8) {
4464 Error("malformed module definition");
4465 return Failure;
4466 }
4467
4468 StringRef Name = Blob;
4469 unsigned Idx = 0;
4470 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4471 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4472 bool IsFramework = Record[Idx++];
4473 bool IsExplicit = Record[Idx++];
4474 bool IsSystem = Record[Idx++];
4475 bool IsExternC = Record[Idx++];
4476 bool InferSubmodules = Record[Idx++];
4477 bool InferExplicitSubmodules = Record[Idx++];
4478 bool InferExportWildcard = Record[Idx++];
4479 bool ConfigMacrosExhaustive = Record[Idx++];
4480
4481 Module *ParentModule = nullptr;
4482 if (Parent)
4483 ParentModule = getSubmodule(Parent);
4484
4485 // Retrieve this (sub)module from the module map, creating it if
4486 // necessary.
4487 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
4488 IsExplicit).first;
4489
4490 // FIXME: set the definition loc for CurrentModule, or call
4491 // ModMap.setInferredModuleAllowedBy()
4492
4493 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4494 if (GlobalIndex >= SubmodulesLoaded.size() ||
4495 SubmodulesLoaded[GlobalIndex]) {
4496 Error("too many submodules");
4497 return Failure;
4498 }
4499
4500 if (!ParentModule) {
4501 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4502 if (CurFile != F.File) {
4503 if (!Diags.isDiagnosticInFlight()) {
4504 Diag(diag::err_module_file_conflict)
4505 << CurrentModule->getTopLevelModuleName()
4506 << CurFile->getName()
4507 << F.File->getName();
4508 }
4509 return Failure;
4510 }
4511 }
4512
4513 CurrentModule->setASTFile(F.File);
4514 }
4515
4516 CurrentModule->Signature = F.Signature;
4517 CurrentModule->IsFromModuleFile = true;
4518 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
4519 CurrentModule->IsExternC = IsExternC;
4520 CurrentModule->InferSubmodules = InferSubmodules;
4521 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4522 CurrentModule->InferExportWildcard = InferExportWildcard;
4523 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
4524 if (DeserializationListener)
4525 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4526
4527 SubmodulesLoaded[GlobalIndex] = CurrentModule;
4528
4529 // Clear out data that will be replaced by what is in the module file.
4530 CurrentModule->LinkLibraries.clear();
4531 CurrentModule->ConfigMacros.clear();
4532 CurrentModule->UnresolvedConflicts.clear();
4533 CurrentModule->Conflicts.clear();
4534
4535 // The module is available unless it's missing a requirement; relevant
4536 // requirements will be (re-)added by SUBMODULE_REQUIRES records.
4537 // Missing headers that were present when the module was built do not
4538 // make it unavailable -- if we got this far, this must be an explicitly
4539 // imported module file.
4540 CurrentModule->Requirements.clear();
4541 CurrentModule->MissingHeaders.clear();
4542 CurrentModule->IsMissingRequirement =
4543 ParentModule && ParentModule->IsMissingRequirement;
4544 CurrentModule->IsAvailable = !CurrentModule->IsMissingRequirement;
4545 break;
4546 }
4547
4548 case SUBMODULE_UMBRELLA_HEADER: {
4549 std::string Filename = Blob;
4550 ResolveImportedPath(F, Filename);
4551 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
4552 if (!CurrentModule->getUmbrellaHeader())
4553 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
4554 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
4555 // This can be a spurious difference caused by changing the VFS to
4556 // point to a different copy of the file, and it is too late to
4557 // to rebuild safely.
4558 // FIXME: If we wrote the virtual paths instead of the 'real' paths,
4559 // after input file validation only real problems would remain and we
4560 // could just error. For now, assume it's okay.
4561 break;
4562 }
4563 }
4564 break;
4565 }
4566
4567 case SUBMODULE_HEADER:
4568 case SUBMODULE_EXCLUDED_HEADER:
4569 case SUBMODULE_PRIVATE_HEADER:
4570 // We lazily associate headers with their modules via the HeaderInfo table.
4571 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4572 // of complete filenames or remove it entirely.
4573 break;
4574
4575 case SUBMODULE_TEXTUAL_HEADER:
4576 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
4577 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
4578 // them here.
4579 break;
4580
4581 case SUBMODULE_TOPHEADER: {
4582 CurrentModule->addTopHeaderFilename(Blob);
4583 break;
4584 }
4585
4586 case SUBMODULE_UMBRELLA_DIR: {
4587 std::string Dirname = Blob;
4588 ResolveImportedPath(F, Dirname);
4589 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
4590 if (!CurrentModule->getUmbrellaDir())
4591 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
4592 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
4593 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4594 Error("mismatched umbrella directories in submodule");
4595 return OutOfDate;
4596 }
4597 }
4598 break;
4599 }
4600
4601 case SUBMODULE_METADATA: {
4602 F.BaseSubmoduleID = getTotalNumSubmodules();
4603 F.LocalNumSubmodules = Record[0];
4604 unsigned LocalBaseSubmoduleID = Record[1];
4605 if (F.LocalNumSubmodules > 0) {
4606 // Introduce the global -> local mapping for submodules within this
4607 // module.
4608 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
4609
4610 // Introduce the local -> global mapping for submodules within this
4611 // module.
4612 F.SubmoduleRemap.insertOrReplace(
4613 std::make_pair(LocalBaseSubmoduleID,
4614 F.BaseSubmoduleID - LocalBaseSubmoduleID));
4615
4616 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
4617 }
4618 break;
4619 }
4620
4621 case SUBMODULE_IMPORTS: {
4622 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
4623 UnresolvedModuleRef Unresolved;
4624 Unresolved.File = &F;
4625 Unresolved.Mod = CurrentModule;
4626 Unresolved.ID = Record[Idx];
4627 Unresolved.Kind = UnresolvedModuleRef::Import;
4628 Unresolved.IsWildcard = false;
4629 UnresolvedModuleRefs.push_back(Unresolved);
4630 }
4631 break;
4632 }
4633
4634 case SUBMODULE_EXPORTS: {
4635 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
4636 UnresolvedModuleRef Unresolved;
4637 Unresolved.File = &F;
4638 Unresolved.Mod = CurrentModule;
4639 Unresolved.ID = Record[Idx];
4640 Unresolved.Kind = UnresolvedModuleRef::Export;
4641 Unresolved.IsWildcard = Record[Idx + 1];
4642 UnresolvedModuleRefs.push_back(Unresolved);
4643 }
4644
4645 // Once we've loaded the set of exports, there's no reason to keep
4646 // the parsed, unresolved exports around.
4647 CurrentModule->UnresolvedExports.clear();
4648 break;
4649 }
4650 case SUBMODULE_REQUIRES: {
4651 CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
4652 Context.getTargetInfo());
4653 break;
4654 }
4655
4656 case SUBMODULE_LINK_LIBRARY:
4657 CurrentModule->LinkLibraries.push_back(
4658 Module::LinkLibrary(Blob, Record[0]));
4659 break;
4660
4661 case SUBMODULE_CONFIG_MACRO:
4662 CurrentModule->ConfigMacros.push_back(Blob.str());
4663 break;
4664
4665 case SUBMODULE_CONFLICT: {
4666 UnresolvedModuleRef Unresolved;
4667 Unresolved.File = &F;
4668 Unresolved.Mod = CurrentModule;
4669 Unresolved.ID = Record[0];
4670 Unresolved.Kind = UnresolvedModuleRef::Conflict;
4671 Unresolved.IsWildcard = false;
4672 Unresolved.String = Blob;
4673 UnresolvedModuleRefs.push_back(Unresolved);
4674 break;
4675 }
4676 }
4677 }
4678 }
4679
4680 /// \brief Parse the record that corresponds to a LangOptions data
4681 /// structure.
4682 ///
4683 /// This routine parses the language options from the AST file and then gives
4684 /// them to the AST listener if one is set.
4685 ///
4686 /// \returns true if the listener deems the file unacceptable, false otherwise.
ParseLanguageOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener,bool AllowCompatibleDifferences)4687 bool ASTReader::ParseLanguageOptions(const RecordData &Record,
4688 bool Complain,
4689 ASTReaderListener &Listener,
4690 bool AllowCompatibleDifferences) {
4691 LangOptions LangOpts;
4692 unsigned Idx = 0;
4693 #define LANGOPT(Name, Bits, Default, Description) \
4694 LangOpts.Name = Record[Idx++];
4695 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4696 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
4697 #include "clang/Basic/LangOptions.def"
4698 #define SANITIZER(NAME, ID) \
4699 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
4700 #include "clang/Basic/Sanitizers.def"
4701
4702 for (unsigned N = Record[Idx++]; N; --N)
4703 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
4704
4705 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
4706 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
4707 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
4708
4709 LangOpts.CurrentModule = ReadString(Record, Idx);
4710
4711 // Comment options.
4712 for (unsigned N = Record[Idx++]; N; --N) {
4713 LangOpts.CommentOpts.BlockCommandNames.push_back(
4714 ReadString(Record, Idx));
4715 }
4716 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
4717
4718 // OpenMP offloading options.
4719 for (unsigned N = Record[Idx++]; N; --N) {
4720 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
4721 }
4722
4723 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
4724
4725 return Listener.ReadLanguageOptions(LangOpts, Complain,
4726 AllowCompatibleDifferences);
4727 }
4728
ParseTargetOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener,bool AllowCompatibleDifferences)4729 bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
4730 ASTReaderListener &Listener,
4731 bool AllowCompatibleDifferences) {
4732 unsigned Idx = 0;
4733 TargetOptions TargetOpts;
4734 TargetOpts.Triple = ReadString(Record, Idx);
4735 TargetOpts.CPU = ReadString(Record, Idx);
4736 TargetOpts.ABI = ReadString(Record, Idx);
4737 for (unsigned N = Record[Idx++]; N; --N) {
4738 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
4739 }
4740 for (unsigned N = Record[Idx++]; N; --N) {
4741 TargetOpts.Features.push_back(ReadString(Record, Idx));
4742 }
4743
4744 return Listener.ReadTargetOptions(TargetOpts, Complain,
4745 AllowCompatibleDifferences);
4746 }
4747
ParseDiagnosticOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener)4748 bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
4749 ASTReaderListener &Listener) {
4750 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
4751 unsigned Idx = 0;
4752 #define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
4753 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4754 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
4755 #include "clang/Basic/DiagnosticOptions.def"
4756
4757 for (unsigned N = Record[Idx++]; N; --N)
4758 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
4759 for (unsigned N = Record[Idx++]; N; --N)
4760 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
4761
4762 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
4763 }
4764
ParseFileSystemOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener)4765 bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
4766 ASTReaderListener &Listener) {
4767 FileSystemOptions FSOpts;
4768 unsigned Idx = 0;
4769 FSOpts.WorkingDir = ReadString(Record, Idx);
4770 return Listener.ReadFileSystemOptions(FSOpts, Complain);
4771 }
4772
ParseHeaderSearchOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener)4773 bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
4774 bool Complain,
4775 ASTReaderListener &Listener) {
4776 HeaderSearchOptions HSOpts;
4777 unsigned Idx = 0;
4778 HSOpts.Sysroot = ReadString(Record, Idx);
4779
4780 // Include entries.
4781 for (unsigned N = Record[Idx++]; N; --N) {
4782 std::string Path = ReadString(Record, Idx);
4783 frontend::IncludeDirGroup Group
4784 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
4785 bool IsFramework = Record[Idx++];
4786 bool IgnoreSysRoot = Record[Idx++];
4787 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
4788 IgnoreSysRoot);
4789 }
4790
4791 // System header prefixes.
4792 for (unsigned N = Record[Idx++]; N; --N) {
4793 std::string Prefix = ReadString(Record, Idx);
4794 bool IsSystemHeader = Record[Idx++];
4795 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
4796 }
4797
4798 HSOpts.ResourceDir = ReadString(Record, Idx);
4799 HSOpts.ModuleCachePath = ReadString(Record, Idx);
4800 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
4801 HSOpts.DisableModuleHash = Record[Idx++];
4802 HSOpts.UseBuiltinIncludes = Record[Idx++];
4803 HSOpts.UseStandardSystemIncludes = Record[Idx++];
4804 HSOpts.UseStandardCXXIncludes = Record[Idx++];
4805 HSOpts.UseLibcxx = Record[Idx++];
4806 std::string SpecificModuleCachePath = ReadString(Record, Idx);
4807
4808 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4809 Complain);
4810 }
4811
ParsePreprocessorOptions(const RecordData & Record,bool Complain,ASTReaderListener & Listener,std::string & SuggestedPredefines)4812 bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
4813 bool Complain,
4814 ASTReaderListener &Listener,
4815 std::string &SuggestedPredefines) {
4816 PreprocessorOptions PPOpts;
4817 unsigned Idx = 0;
4818
4819 // Macro definitions/undefs
4820 for (unsigned N = Record[Idx++]; N; --N) {
4821 std::string Macro = ReadString(Record, Idx);
4822 bool IsUndef = Record[Idx++];
4823 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
4824 }
4825
4826 // Includes
4827 for (unsigned N = Record[Idx++]; N; --N) {
4828 PPOpts.Includes.push_back(ReadString(Record, Idx));
4829 }
4830
4831 // Macro Includes
4832 for (unsigned N = Record[Idx++]; N; --N) {
4833 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
4834 }
4835
4836 PPOpts.UsePredefines = Record[Idx++];
4837 PPOpts.DetailedRecord = Record[Idx++];
4838 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
4839 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
4840 PPOpts.ObjCXXARCStandardLibrary =
4841 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
4842 SuggestedPredefines.clear();
4843 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
4844 SuggestedPredefines);
4845 }
4846
4847 std::pair<ModuleFile *, unsigned>
getModulePreprocessedEntity(unsigned GlobalIndex)4848 ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
4849 GlobalPreprocessedEntityMapType::iterator
4850 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
4851 assert(I != GlobalPreprocessedEntityMap.end() &&
4852 "Corrupted global preprocessed entity map");
4853 ModuleFile *M = I->second;
4854 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
4855 return std::make_pair(M, LocalIndex);
4856 }
4857
4858 llvm::iterator_range<PreprocessingRecord::iterator>
getModulePreprocessedEntities(ModuleFile & Mod) const4859 ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
4860 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
4861 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
4862 Mod.NumPreprocessedEntities);
4863
4864 return llvm::make_range(PreprocessingRecord::iterator(),
4865 PreprocessingRecord::iterator());
4866 }
4867
4868 llvm::iterator_range<ASTReader::ModuleDeclIterator>
getModuleFileLevelDecls(ModuleFile & Mod)4869 ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
4870 return llvm::make_range(
4871 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
4872 ModuleDeclIterator(this, &Mod,
4873 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
4874 }
4875
ReadPreprocessedEntity(unsigned Index)4876 PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
4877 PreprocessedEntityID PPID = Index+1;
4878 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4879 ModuleFile &M = *PPInfo.first;
4880 unsigned LocalIndex = PPInfo.second;
4881 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4882
4883 if (!PP.getPreprocessingRecord()) {
4884 Error("no preprocessing record");
4885 return nullptr;
4886 }
4887
4888 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
4889 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
4890
4891 llvm::BitstreamEntry Entry =
4892 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
4893 if (Entry.Kind != llvm::BitstreamEntry::Record)
4894 return nullptr;
4895
4896 // Read the record.
4897 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
4898 TranslateSourceLocation(M, PPOffs.getEnd()));
4899 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
4900 StringRef Blob;
4901 RecordData Record;
4902 PreprocessorDetailRecordTypes RecType =
4903 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
4904 Entry.ID, Record, &Blob);
4905 switch (RecType) {
4906 case PPD_MACRO_EXPANSION: {
4907 bool isBuiltin = Record[0];
4908 IdentifierInfo *Name = nullptr;
4909 MacroDefinitionRecord *Def = nullptr;
4910 if (isBuiltin)
4911 Name = getLocalIdentifier(M, Record[1]);
4912 else {
4913 PreprocessedEntityID GlobalID =
4914 getGlobalPreprocessedEntityID(M, Record[1]);
4915 Def = cast<MacroDefinitionRecord>(
4916 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
4917 }
4918
4919 MacroExpansion *ME;
4920 if (isBuiltin)
4921 ME = new (PPRec) MacroExpansion(Name, Range);
4922 else
4923 ME = new (PPRec) MacroExpansion(Def, Range);
4924
4925 return ME;
4926 }
4927
4928 case PPD_MACRO_DEFINITION: {
4929 // Decode the identifier info and then check again; if the macro is
4930 // still defined and associated with the identifier,
4931 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
4932 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
4933
4934 if (DeserializationListener)
4935 DeserializationListener->MacroDefinitionRead(PPID, MD);
4936
4937 return MD;
4938 }
4939
4940 case PPD_INCLUSION_DIRECTIVE: {
4941 const char *FullFileNameStart = Blob.data() + Record[0];
4942 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
4943 const FileEntry *File = nullptr;
4944 if (!FullFileName.empty())
4945 File = PP.getFileManager().getFile(FullFileName);
4946
4947 // FIXME: Stable encoding
4948 InclusionDirective::InclusionKind Kind
4949 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
4950 InclusionDirective *ID
4951 = new (PPRec) InclusionDirective(PPRec, Kind,
4952 StringRef(Blob.data(), Record[0]),
4953 Record[1], Record[3],
4954 File,
4955 Range);
4956 return ID;
4957 }
4958 }
4959
4960 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
4961 }
4962
4963 /// \brief \arg SLocMapI points at a chunk of a module that contains no
4964 /// preprocessed entities or the entities it contains are not the ones we are
4965 /// looking for. Find the next module that contains entities and return the ID
4966 /// of the first entry.
findNextPreprocessedEntity(GlobalSLocOffsetMapType::const_iterator SLocMapI) const4967 PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
4968 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
4969 ++SLocMapI;
4970 for (GlobalSLocOffsetMapType::const_iterator
4971 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
4972 ModuleFile &M = *SLocMapI->second;
4973 if (M.NumPreprocessedEntities)
4974 return M.BasePreprocessedEntityID;
4975 }
4976
4977 return getTotalNumPreprocessedEntities();
4978 }
4979
4980 namespace {
4981
4982 struct PPEntityComp {
4983 const ASTReader &Reader;
4984 ModuleFile &M;
4985
PPEntityComp__anonfbeb47490711::PPEntityComp4986 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
4987
operator ()__anonfbeb47490711::PPEntityComp4988 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4989 SourceLocation LHS = getLoc(L);
4990 SourceLocation RHS = getLoc(R);
4991 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4992 }
4993
operator ()__anonfbeb47490711::PPEntityComp4994 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
4995 SourceLocation LHS = getLoc(L);
4996 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4997 }
4998
operator ()__anonfbeb47490711::PPEntityComp4999 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5000 SourceLocation RHS = getLoc(R);
5001 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5002 }
5003
getLoc__anonfbeb47490711::PPEntityComp5004 SourceLocation getLoc(const PPEntityOffset &PPE) const {
5005 return Reader.TranslateSourceLocation(M, PPE.getBegin());
5006 }
5007 };
5008
5009 }
5010
findPreprocessedEntity(SourceLocation Loc,bool EndsAfter) const5011 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5012 bool EndsAfter) const {
5013 if (SourceMgr.isLocalSourceLocation(Loc))
5014 return getTotalNumPreprocessedEntities();
5015
5016 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5017 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
5018 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5019 "Corrupted global sloc offset map");
5020
5021 if (SLocMapI->second->NumPreprocessedEntities == 0)
5022 return findNextPreprocessedEntity(SLocMapI);
5023
5024 ModuleFile &M = *SLocMapI->second;
5025 typedef const PPEntityOffset *pp_iterator;
5026 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5027 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5028
5029 size_t Count = M.NumPreprocessedEntities;
5030 size_t Half;
5031 pp_iterator First = pp_begin;
5032 pp_iterator PPI;
5033
5034 if (EndsAfter) {
5035 PPI = std::upper_bound(pp_begin, pp_end, Loc,
5036 PPEntityComp(*this, M));
5037 } else {
5038 // Do a binary search manually instead of using std::lower_bound because
5039 // The end locations of entities may be unordered (when a macro expansion
5040 // is inside another macro argument), but for this case it is not important
5041 // whether we get the first macro expansion or its containing macro.
5042 while (Count > 0) {
5043 Half = Count / 2;
5044 PPI = First;
5045 std::advance(PPI, Half);
5046 if (SourceMgr.isBeforeInTranslationUnit(
5047 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
5048 First = PPI;
5049 ++First;
5050 Count = Count - Half - 1;
5051 } else
5052 Count = Half;
5053 }
5054 }
5055
5056 if (PPI == pp_end)
5057 return findNextPreprocessedEntity(SLocMapI);
5058
5059 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5060 }
5061
5062 /// \brief Returns a pair of [Begin, End) indices of preallocated
5063 /// preprocessed entities that \arg Range encompasses.
5064 std::pair<unsigned, unsigned>
findPreprocessedEntitiesInRange(SourceRange Range)5065 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5066 if (Range.isInvalid())
5067 return std::make_pair(0,0);
5068 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5069
5070 PreprocessedEntityID BeginID =
5071 findPreprocessedEntity(Range.getBegin(), false);
5072 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
5073 return std::make_pair(BeginID, EndID);
5074 }
5075
5076 /// \brief Optionally returns true or false if the preallocated preprocessed
5077 /// entity with index \arg Index came from file \arg FID.
isPreprocessedEntityInFileID(unsigned Index,FileID FID)5078 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
5079 FileID FID) {
5080 if (FID.isInvalid())
5081 return false;
5082
5083 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5084 ModuleFile &M = *PPInfo.first;
5085 unsigned LocalIndex = PPInfo.second;
5086 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5087
5088 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
5089 if (Loc.isInvalid())
5090 return false;
5091
5092 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5093 return true;
5094 else
5095 return false;
5096 }
5097
5098 namespace {
5099 /// \brief Visitor used to search for information about a header file.
5100 class HeaderFileInfoVisitor {
5101 const FileEntry *FE;
5102
5103 Optional<HeaderFileInfo> HFI;
5104
5105 public:
HeaderFileInfoVisitor(const FileEntry * FE)5106 explicit HeaderFileInfoVisitor(const FileEntry *FE)
5107 : FE(FE) { }
5108
operator ()(ModuleFile & M)5109 bool operator()(ModuleFile &M) {
5110 HeaderFileInfoLookupTable *Table
5111 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5112 if (!Table)
5113 return false;
5114
5115 // Look in the on-disk hash table for an entry for this file name.
5116 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
5117 if (Pos == Table->end())
5118 return false;
5119
5120 HFI = *Pos;
5121 return true;
5122 }
5123
getHeaderFileInfo() const5124 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
5125 };
5126 }
5127
GetHeaderFileInfo(const FileEntry * FE)5128 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
5129 HeaderFileInfoVisitor Visitor(FE);
5130 ModuleMgr.visit(Visitor);
5131 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
5132 return *HFI;
5133
5134 return HeaderFileInfo();
5135 }
5136
ReadPragmaDiagnosticMappings(DiagnosticsEngine & Diag)5137 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5138 // FIXME: Make it work properly with modules.
5139 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
5140 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
5141 ModuleFile &F = *(*I);
5142 unsigned Idx = 0;
5143 DiagStates.clear();
5144 assert(!Diag.DiagStates.empty());
5145 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
5146 while (Idx < F.PragmaDiagMappings.size()) {
5147 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5148 unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
5149 if (DiagStateID != 0) {
5150 Diag.DiagStatePoints.push_back(
5151 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
5152 FullSourceLoc(Loc, SourceMgr)));
5153 continue;
5154 }
5155
5156 assert(DiagStateID == 0);
5157 // A new DiagState was created here.
5158 Diag.DiagStates.push_back(*Diag.GetCurDiagState());
5159 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
5160 DiagStates.push_back(NewState);
5161 Diag.DiagStatePoints.push_back(
5162 DiagnosticsEngine::DiagStatePoint(NewState,
5163 FullSourceLoc(Loc, SourceMgr)));
5164 while (1) {
5165 assert(Idx < F.PragmaDiagMappings.size() &&
5166 "Invalid data, didn't find '-1' marking end of diag/map pairs");
5167 if (Idx >= F.PragmaDiagMappings.size()) {
5168 break; // Something is messed up but at least avoid infinite loop in
5169 // release build.
5170 }
5171 unsigned DiagID = F.PragmaDiagMappings[Idx++];
5172 if (DiagID == (unsigned)-1) {
5173 break; // no more diag/map pairs for this location.
5174 }
5175 diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
5176 DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
5177 Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
5178 }
5179 }
5180 }
5181 }
5182
5183 /// \brief Get the correct cursor and offset for loading a type.
TypeCursorForIndex(unsigned Index)5184 ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5185 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5186 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5187 ModuleFile *M = I->second;
5188 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5189 }
5190
5191 /// \brief Read and return the type with the given index..
5192 ///
5193 /// The index is the type ID, shifted and minus the number of predefs. This
5194 /// routine actually reads the record corresponding to the type at the given
5195 /// location. It is a helper routine for GetType, which deals with reading type
5196 /// IDs.
readTypeRecord(unsigned Index)5197 QualType ASTReader::readTypeRecord(unsigned Index) {
5198 RecordLocation Loc = TypeCursorForIndex(Index);
5199 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
5200
5201 // Keep track of where we are in the stream, then jump back there
5202 // after reading this type.
5203 SavedStreamPosition SavedPosition(DeclsCursor);
5204
5205 ReadingKindTracker ReadingKind(Read_Type, *this);
5206
5207 // Note that we are loading a type record.
5208 Deserializing AType(this);
5209
5210 unsigned Idx = 0;
5211 DeclsCursor.JumpToBit(Loc.Offset);
5212 RecordData Record;
5213 unsigned Code = DeclsCursor.ReadCode();
5214 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
5215 case TYPE_EXT_QUAL: {
5216 if (Record.size() != 2) {
5217 Error("Incorrect encoding of extended qualifier type");
5218 return QualType();
5219 }
5220 QualType Base = readType(*Loc.F, Record, Idx);
5221 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5222 return Context.getQualifiedType(Base, Quals);
5223 }
5224
5225 case TYPE_COMPLEX: {
5226 if (Record.size() != 1) {
5227 Error("Incorrect encoding of complex type");
5228 return QualType();
5229 }
5230 QualType ElemType = readType(*Loc.F, Record, Idx);
5231 return Context.getComplexType(ElemType);
5232 }
5233
5234 case TYPE_POINTER: {
5235 if (Record.size() != 1) {
5236 Error("Incorrect encoding of pointer type");
5237 return QualType();
5238 }
5239 QualType PointeeType = readType(*Loc.F, Record, Idx);
5240 return Context.getPointerType(PointeeType);
5241 }
5242
5243 case TYPE_DECAYED: {
5244 if (Record.size() != 1) {
5245 Error("Incorrect encoding of decayed type");
5246 return QualType();
5247 }
5248 QualType OriginalType = readType(*Loc.F, Record, Idx);
5249 QualType DT = Context.getAdjustedParameterType(OriginalType);
5250 if (!isa<DecayedType>(DT))
5251 Error("Decayed type does not decay");
5252 return DT;
5253 }
5254
5255 case TYPE_ADJUSTED: {
5256 if (Record.size() != 2) {
5257 Error("Incorrect encoding of adjusted type");
5258 return QualType();
5259 }
5260 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5261 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5262 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5263 }
5264
5265 case TYPE_BLOCK_POINTER: {
5266 if (Record.size() != 1) {
5267 Error("Incorrect encoding of block pointer type");
5268 return QualType();
5269 }
5270 QualType PointeeType = readType(*Loc.F, Record, Idx);
5271 return Context.getBlockPointerType(PointeeType);
5272 }
5273
5274 case TYPE_LVALUE_REFERENCE: {
5275 if (Record.size() != 2) {
5276 Error("Incorrect encoding of lvalue reference type");
5277 return QualType();
5278 }
5279 QualType PointeeType = readType(*Loc.F, Record, Idx);
5280 return Context.getLValueReferenceType(PointeeType, Record[1]);
5281 }
5282
5283 case TYPE_RVALUE_REFERENCE: {
5284 if (Record.size() != 1) {
5285 Error("Incorrect encoding of rvalue reference type");
5286 return QualType();
5287 }
5288 QualType PointeeType = readType(*Loc.F, Record, Idx);
5289 return Context.getRValueReferenceType(PointeeType);
5290 }
5291
5292 case TYPE_MEMBER_POINTER: {
5293 if (Record.size() != 2) {
5294 Error("Incorrect encoding of member pointer type");
5295 return QualType();
5296 }
5297 QualType PointeeType = readType(*Loc.F, Record, Idx);
5298 QualType ClassType = readType(*Loc.F, Record, Idx);
5299 if (PointeeType.isNull() || ClassType.isNull())
5300 return QualType();
5301
5302 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5303 }
5304
5305 case TYPE_CONSTANT_ARRAY: {
5306 QualType ElementType = readType(*Loc.F, Record, Idx);
5307 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5308 unsigned IndexTypeQuals = Record[2];
5309 unsigned Idx = 3;
5310 llvm::APInt Size = ReadAPInt(Record, Idx);
5311 return Context.getConstantArrayType(ElementType, Size,
5312 ASM, IndexTypeQuals);
5313 }
5314
5315 case TYPE_INCOMPLETE_ARRAY: {
5316 QualType ElementType = readType(*Loc.F, Record, Idx);
5317 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5318 unsigned IndexTypeQuals = Record[2];
5319 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5320 }
5321
5322 case TYPE_VARIABLE_ARRAY: {
5323 QualType ElementType = readType(*Loc.F, Record, Idx);
5324 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5325 unsigned IndexTypeQuals = Record[2];
5326 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5327 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5328 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5329 ASM, IndexTypeQuals,
5330 SourceRange(LBLoc, RBLoc));
5331 }
5332
5333 case TYPE_VECTOR: {
5334 if (Record.size() != 3) {
5335 Error("incorrect encoding of vector type in AST file");
5336 return QualType();
5337 }
5338
5339 QualType ElementType = readType(*Loc.F, Record, Idx);
5340 unsigned NumElements = Record[1];
5341 unsigned VecKind = Record[2];
5342 return Context.getVectorType(ElementType, NumElements,
5343 (VectorType::VectorKind)VecKind);
5344 }
5345
5346 case TYPE_EXT_VECTOR: {
5347 if (Record.size() != 3) {
5348 Error("incorrect encoding of extended vector type in AST file");
5349 return QualType();
5350 }
5351
5352 QualType ElementType = readType(*Loc.F, Record, Idx);
5353 unsigned NumElements = Record[1];
5354 return Context.getExtVectorType(ElementType, NumElements);
5355 }
5356
5357 case TYPE_FUNCTION_NO_PROTO: {
5358 if (Record.size() != 6) {
5359 Error("incorrect encoding of no-proto function type");
5360 return QualType();
5361 }
5362 QualType ResultType = readType(*Loc.F, Record, Idx);
5363 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5364 (CallingConv)Record[4], Record[5]);
5365 return Context.getFunctionNoProtoType(ResultType, Info);
5366 }
5367
5368 case TYPE_FUNCTION_PROTO: {
5369 QualType ResultType = readType(*Loc.F, Record, Idx);
5370
5371 FunctionProtoType::ExtProtoInfo EPI;
5372 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5373 /*hasregparm*/ Record[2],
5374 /*regparm*/ Record[3],
5375 static_cast<CallingConv>(Record[4]),
5376 /*produces*/ Record[5]);
5377
5378 unsigned Idx = 6;
5379
5380 EPI.Variadic = Record[Idx++];
5381 EPI.HasTrailingReturn = Record[Idx++];
5382 EPI.TypeQuals = Record[Idx++];
5383 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
5384 SmallVector<QualType, 8> ExceptionStorage;
5385 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
5386
5387 unsigned NumParams = Record[Idx++];
5388 SmallVector<QualType, 16> ParamTypes;
5389 for (unsigned I = 0; I != NumParams; ++I)
5390 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5391
5392 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
5393 if (Idx != Record.size()) {
5394 for (unsigned I = 0; I != NumParams; ++I)
5395 ExtParameterInfos.push_back(
5396 FunctionProtoType::ExtParameterInfo
5397 ::getFromOpaqueValue(Record[Idx++]));
5398 EPI.ExtParameterInfos = ExtParameterInfos.data();
5399 }
5400
5401 assert(Idx == Record.size());
5402
5403 return Context.getFunctionType(ResultType, ParamTypes, EPI);
5404 }
5405
5406 case TYPE_UNRESOLVED_USING: {
5407 unsigned Idx = 0;
5408 return Context.getTypeDeclType(
5409 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5410 }
5411
5412 case TYPE_TYPEDEF: {
5413 if (Record.size() != 2) {
5414 Error("incorrect encoding of typedef type");
5415 return QualType();
5416 }
5417 unsigned Idx = 0;
5418 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5419 QualType Canonical = readType(*Loc.F, Record, Idx);
5420 if (!Canonical.isNull())
5421 Canonical = Context.getCanonicalType(Canonical);
5422 return Context.getTypedefType(Decl, Canonical);
5423 }
5424
5425 case TYPE_TYPEOF_EXPR:
5426 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5427
5428 case TYPE_TYPEOF: {
5429 if (Record.size() != 1) {
5430 Error("incorrect encoding of typeof(type) in AST file");
5431 return QualType();
5432 }
5433 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5434 return Context.getTypeOfType(UnderlyingType);
5435 }
5436
5437 case TYPE_DECLTYPE: {
5438 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5439 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5440 }
5441
5442 case TYPE_UNARY_TRANSFORM: {
5443 QualType BaseType = readType(*Loc.F, Record, Idx);
5444 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5445 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
5446 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5447 }
5448
5449 case TYPE_AUTO: {
5450 QualType Deduced = readType(*Loc.F, Record, Idx);
5451 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
5452 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
5453 return Context.getAutoType(Deduced, Keyword, IsDependent);
5454 }
5455
5456 case TYPE_RECORD: {
5457 if (Record.size() != 2) {
5458 Error("incorrect encoding of record type");
5459 return QualType();
5460 }
5461 unsigned Idx = 0;
5462 bool IsDependent = Record[Idx++];
5463 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
5464 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
5465 QualType T = Context.getRecordType(RD);
5466 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5467 return T;
5468 }
5469
5470 case TYPE_ENUM: {
5471 if (Record.size() != 2) {
5472 Error("incorrect encoding of enum type");
5473 return QualType();
5474 }
5475 unsigned Idx = 0;
5476 bool IsDependent = Record[Idx++];
5477 QualType T
5478 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
5479 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5480 return T;
5481 }
5482
5483 case TYPE_ATTRIBUTED: {
5484 if (Record.size() != 3) {
5485 Error("incorrect encoding of attributed type");
5486 return QualType();
5487 }
5488 QualType modifiedType = readType(*Loc.F, Record, Idx);
5489 QualType equivalentType = readType(*Loc.F, Record, Idx);
5490 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
5491 return Context.getAttributedType(kind, modifiedType, equivalentType);
5492 }
5493
5494 case TYPE_PAREN: {
5495 if (Record.size() != 1) {
5496 Error("incorrect encoding of paren type");
5497 return QualType();
5498 }
5499 QualType InnerType = readType(*Loc.F, Record, Idx);
5500 return Context.getParenType(InnerType);
5501 }
5502
5503 case TYPE_PACK_EXPANSION: {
5504 if (Record.size() != 2) {
5505 Error("incorrect encoding of pack expansion type");
5506 return QualType();
5507 }
5508 QualType Pattern = readType(*Loc.F, Record, Idx);
5509 if (Pattern.isNull())
5510 return QualType();
5511 Optional<unsigned> NumExpansions;
5512 if (Record[1])
5513 NumExpansions = Record[1] - 1;
5514 return Context.getPackExpansionType(Pattern, NumExpansions);
5515 }
5516
5517 case TYPE_ELABORATED: {
5518 unsigned Idx = 0;
5519 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5520 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5521 QualType NamedType = readType(*Loc.F, Record, Idx);
5522 return Context.getElaboratedType(Keyword, NNS, NamedType);
5523 }
5524
5525 case TYPE_OBJC_INTERFACE: {
5526 unsigned Idx = 0;
5527 ObjCInterfaceDecl *ItfD
5528 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
5529 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
5530 }
5531
5532 case TYPE_OBJC_OBJECT: {
5533 unsigned Idx = 0;
5534 QualType Base = readType(*Loc.F, Record, Idx);
5535 unsigned NumTypeArgs = Record[Idx++];
5536 SmallVector<QualType, 4> TypeArgs;
5537 for (unsigned I = 0; I != NumTypeArgs; ++I)
5538 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
5539 unsigned NumProtos = Record[Idx++];
5540 SmallVector<ObjCProtocolDecl*, 4> Protos;
5541 for (unsigned I = 0; I != NumProtos; ++I)
5542 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
5543 bool IsKindOf = Record[Idx++];
5544 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
5545 }
5546
5547 case TYPE_OBJC_OBJECT_POINTER: {
5548 unsigned Idx = 0;
5549 QualType Pointee = readType(*Loc.F, Record, Idx);
5550 return Context.getObjCObjectPointerType(Pointee);
5551 }
5552
5553 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
5554 unsigned Idx = 0;
5555 QualType Parm = readType(*Loc.F, Record, Idx);
5556 QualType Replacement = readType(*Loc.F, Record, Idx);
5557 return Context.getSubstTemplateTypeParmType(
5558 cast<TemplateTypeParmType>(Parm),
5559 Context.getCanonicalType(Replacement));
5560 }
5561
5562 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
5563 unsigned Idx = 0;
5564 QualType Parm = readType(*Loc.F, Record, Idx);
5565 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
5566 return Context.getSubstTemplateTypeParmPackType(
5567 cast<TemplateTypeParmType>(Parm),
5568 ArgPack);
5569 }
5570
5571 case TYPE_INJECTED_CLASS_NAME: {
5572 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
5573 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
5574 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
5575 // for AST reading, too much interdependencies.
5576 const Type *T = nullptr;
5577 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
5578 if (const Type *Existing = DI->getTypeForDecl()) {
5579 T = Existing;
5580 break;
5581 }
5582 }
5583 if (!T) {
5584 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
5585 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
5586 DI->setTypeForDecl(T);
5587 }
5588 return QualType(T, 0);
5589 }
5590
5591 case TYPE_TEMPLATE_TYPE_PARM: {
5592 unsigned Idx = 0;
5593 unsigned Depth = Record[Idx++];
5594 unsigned Index = Record[Idx++];
5595 bool Pack = Record[Idx++];
5596 TemplateTypeParmDecl *D
5597 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
5598 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
5599 }
5600
5601 case TYPE_DEPENDENT_NAME: {
5602 unsigned Idx = 0;
5603 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5604 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5605 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
5606 QualType Canon = readType(*Loc.F, Record, Idx);
5607 if (!Canon.isNull())
5608 Canon = Context.getCanonicalType(Canon);
5609 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
5610 }
5611
5612 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
5613 unsigned Idx = 0;
5614 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5615 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5616 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
5617 unsigned NumArgs = Record[Idx++];
5618 SmallVector<TemplateArgument, 8> Args;
5619 Args.reserve(NumArgs);
5620 while (NumArgs--)
5621 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
5622 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
5623 Args);
5624 }
5625
5626 case TYPE_DEPENDENT_SIZED_ARRAY: {
5627 unsigned Idx = 0;
5628
5629 // ArrayType
5630 QualType ElementType = readType(*Loc.F, Record, Idx);
5631 ArrayType::ArraySizeModifier ASM
5632 = (ArrayType::ArraySizeModifier)Record[Idx++];
5633 unsigned IndexTypeQuals = Record[Idx++];
5634
5635 // DependentSizedArrayType
5636 Expr *NumElts = ReadExpr(*Loc.F);
5637 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
5638
5639 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
5640 IndexTypeQuals, Brackets);
5641 }
5642
5643 case TYPE_TEMPLATE_SPECIALIZATION: {
5644 unsigned Idx = 0;
5645 bool IsDependent = Record[Idx++];
5646 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
5647 SmallVector<TemplateArgument, 8> Args;
5648 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
5649 QualType Underlying = readType(*Loc.F, Record, Idx);
5650 QualType T;
5651 if (Underlying.isNull())
5652 T = Context.getCanonicalTemplateSpecializationType(Name, Args);
5653 else
5654 T = Context.getTemplateSpecializationType(Name, Args, Underlying);
5655 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5656 return T;
5657 }
5658
5659 case TYPE_ATOMIC: {
5660 if (Record.size() != 1) {
5661 Error("Incorrect encoding of atomic type");
5662 return QualType();
5663 }
5664 QualType ValueType = readType(*Loc.F, Record, Idx);
5665 return Context.getAtomicType(ValueType);
5666 }
5667
5668 case TYPE_PIPE: {
5669 if (Record.size() != 1) {
5670 Error("Incorrect encoding of pipe type");
5671 return QualType();
5672 }
5673
5674 // Reading the pipe element type.
5675 QualType ElementType = readType(*Loc.F, Record, Idx);
5676 return Context.getPipeType(ElementType);
5677 }
5678 }
5679 llvm_unreachable("Invalid TypeCode!");
5680 }
5681
readExceptionSpec(ModuleFile & ModuleFile,SmallVectorImpl<QualType> & Exceptions,FunctionProtoType::ExceptionSpecInfo & ESI,const RecordData & Record,unsigned & Idx)5682 void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
5683 SmallVectorImpl<QualType> &Exceptions,
5684 FunctionProtoType::ExceptionSpecInfo &ESI,
5685 const RecordData &Record, unsigned &Idx) {
5686 ExceptionSpecificationType EST =
5687 static_cast<ExceptionSpecificationType>(Record[Idx++]);
5688 ESI.Type = EST;
5689 if (EST == EST_Dynamic) {
5690 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
5691 Exceptions.push_back(readType(ModuleFile, Record, Idx));
5692 ESI.Exceptions = Exceptions;
5693 } else if (EST == EST_ComputedNoexcept) {
5694 ESI.NoexceptExpr = ReadExpr(ModuleFile);
5695 } else if (EST == EST_Uninstantiated) {
5696 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5697 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5698 } else if (EST == EST_Unevaluated) {
5699 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5700 }
5701 }
5702
5703 class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
5704 ASTReader &Reader;
5705 ModuleFile &F;
5706 const ASTReader::RecordData &Record;
5707 unsigned &Idx;
5708
ReadSourceLocation(const ASTReader::RecordData & R,unsigned & I)5709 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
5710 unsigned &I) {
5711 return Reader.ReadSourceLocation(F, R, I);
5712 }
5713
5714 template<typename T>
ReadDeclAs(const ASTReader::RecordData & Record,unsigned & Idx)5715 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
5716 return Reader.ReadDeclAs<T>(F, Record, Idx);
5717 }
5718
5719 public:
TypeLocReader(ASTReader & Reader,ModuleFile & F,const ASTReader::RecordData & Record,unsigned & Idx)5720 TypeLocReader(ASTReader &Reader, ModuleFile &F,
5721 const ASTReader::RecordData &Record, unsigned &Idx)
5722 : Reader(Reader), F(F), Record(Record), Idx(Idx)
5723 { }
5724
5725 // We want compile-time assurance that we've enumerated all of
5726 // these, so unfortunately we have to declare them first, then
5727 // define them out-of-line.
5728 #define ABSTRACT_TYPELOC(CLASS, PARENT)
5729 #define TYPELOC(CLASS, PARENT) \
5730 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
5731 #include "clang/AST/TypeLocNodes.def"
5732
5733 void VisitFunctionTypeLoc(FunctionTypeLoc);
5734 void VisitArrayTypeLoc(ArrayTypeLoc);
5735 };
5736
VisitQualifiedTypeLoc(QualifiedTypeLoc TL)5737 void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5738 // nothing to do
5739 }
VisitBuiltinTypeLoc(BuiltinTypeLoc TL)5740 void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5741 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
5742 if (TL.needsExtraLocalData()) {
5743 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
5744 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
5745 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
5746 TL.setModeAttr(Record[Idx++]);
5747 }
5748 }
VisitComplexTypeLoc(ComplexTypeLoc TL)5749 void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
5750 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5751 }
VisitPointerTypeLoc(PointerTypeLoc TL)5752 void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
5753 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5754 }
VisitDecayedTypeLoc(DecayedTypeLoc TL)5755 void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5756 // nothing to do
5757 }
VisitAdjustedTypeLoc(AdjustedTypeLoc TL)5758 void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5759 // nothing to do
5760 }
VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL)5761 void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5762 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
5763 }
VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL)5764 void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5765 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
5766 }
VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL)5767 void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5768 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
5769 }
VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL)5770 void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5771 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5772 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5773 }
VisitArrayTypeLoc(ArrayTypeLoc TL)5774 void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
5775 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
5776 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
5777 if (Record[Idx++])
5778 TL.setSizeExpr(Reader.ReadExpr(F));
5779 else
5780 TL.setSizeExpr(nullptr);
5781 }
VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL)5782 void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
5783 VisitArrayTypeLoc(TL);
5784 }
VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL)5785 void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
5786 VisitArrayTypeLoc(TL);
5787 }
VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL)5788 void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
5789 VisitArrayTypeLoc(TL);
5790 }
VisitDependentSizedArrayTypeLoc(DependentSizedArrayTypeLoc TL)5791 void TypeLocReader::VisitDependentSizedArrayTypeLoc(
5792 DependentSizedArrayTypeLoc TL) {
5793 VisitArrayTypeLoc(TL);
5794 }
VisitDependentSizedExtVectorTypeLoc(DependentSizedExtVectorTypeLoc TL)5795 void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
5796 DependentSizedExtVectorTypeLoc TL) {
5797 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5798 }
VisitVectorTypeLoc(VectorTypeLoc TL)5799 void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
5800 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5801 }
VisitExtVectorTypeLoc(ExtVectorTypeLoc TL)5802 void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
5803 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5804 }
VisitFunctionTypeLoc(FunctionTypeLoc TL)5805 void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5806 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
5807 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5808 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5809 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
5810 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
5811 TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
5812 }
5813 }
VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL)5814 void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
5815 VisitFunctionTypeLoc(TL);
5816 }
VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL)5817 void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
5818 VisitFunctionTypeLoc(TL);
5819 }
VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL)5820 void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5821 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5822 }
VisitTypedefTypeLoc(TypedefTypeLoc TL)5823 void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5824 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5825 }
VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL)5826 void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5827 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5828 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5829 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5830 }
VisitTypeOfTypeLoc(TypeOfTypeLoc TL)5831 void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5832 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5833 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5834 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5835 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5836 }
VisitDecltypeTypeLoc(DecltypeTypeLoc TL)5837 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
5838 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5839 }
VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL)5840 void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5841 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5842 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5843 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5844 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5845 }
VisitAutoTypeLoc(AutoTypeLoc TL)5846 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
5847 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5848 }
VisitRecordTypeLoc(RecordTypeLoc TL)5849 void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
5850 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5851 }
VisitEnumTypeLoc(EnumTypeLoc TL)5852 void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
5853 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5854 }
VisitAttributedTypeLoc(AttributedTypeLoc TL)5855 void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5856 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
5857 if (TL.hasAttrOperand()) {
5858 SourceRange range;
5859 range.setBegin(ReadSourceLocation(Record, Idx));
5860 range.setEnd(ReadSourceLocation(Record, Idx));
5861 TL.setAttrOperandParensRange(range);
5862 }
5863 if (TL.hasAttrExprOperand()) {
5864 if (Record[Idx++])
5865 TL.setAttrExprOperand(Reader.ReadExpr(F));
5866 else
5867 TL.setAttrExprOperand(nullptr);
5868 } else if (TL.hasAttrEnumOperand())
5869 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
5870 }
VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL)5871 void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
5872 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5873 }
VisitSubstTemplateTypeParmTypeLoc(SubstTemplateTypeParmTypeLoc TL)5874 void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
5875 SubstTemplateTypeParmTypeLoc TL) {
5876 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5877 }
VisitSubstTemplateTypeParmPackTypeLoc(SubstTemplateTypeParmPackTypeLoc TL)5878 void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
5879 SubstTemplateTypeParmPackTypeLoc TL) {
5880 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5881 }
VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL)5882 void TypeLocReader::VisitTemplateSpecializationTypeLoc(
5883 TemplateSpecializationTypeLoc TL) {
5884 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5885 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5886 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5887 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5888 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
5889 TL.setArgLocInfo(i,
5890 Reader.GetTemplateArgumentLocInfo(F,
5891 TL.getTypePtr()->getArg(i).getKind(),
5892 Record, Idx));
5893 }
VisitParenTypeLoc(ParenTypeLoc TL)5894 void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
5895 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5896 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5897 }
VisitElaboratedTypeLoc(ElaboratedTypeLoc TL)5898 void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5899 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5900 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5901 }
VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL)5902 void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
5903 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5904 }
VisitDependentNameTypeLoc(DependentNameTypeLoc TL)5905 void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5906 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5907 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5908 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5909 }
VisitDependentTemplateSpecializationTypeLoc(DependentTemplateSpecializationTypeLoc TL)5910 void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
5911 DependentTemplateSpecializationTypeLoc TL) {
5912 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5913 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5914 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5915 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5916 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5917 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5918 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
5919 TL.setArgLocInfo(I,
5920 Reader.GetTemplateArgumentLocInfo(F,
5921 TL.getTypePtr()->getArg(I).getKind(),
5922 Record, Idx));
5923 }
VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL)5924 void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
5925 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
5926 }
VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL)5927 void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5928 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5929 }
VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL)5930 void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5931 TL.setHasBaseTypeAsWritten(Record[Idx++]);
5932 TL.setTypeArgsLAngleLoc(ReadSourceLocation(Record, Idx));
5933 TL.setTypeArgsRAngleLoc(ReadSourceLocation(Record, Idx));
5934 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
5935 TL.setTypeArgTInfo(i, Reader.GetTypeSourceInfo(F, Record, Idx));
5936 TL.setProtocolLAngleLoc(ReadSourceLocation(Record, Idx));
5937 TL.setProtocolRAngleLoc(ReadSourceLocation(Record, Idx));
5938 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
5939 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
5940 }
VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL)5941 void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5942 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5943 }
VisitAtomicTypeLoc(AtomicTypeLoc TL)5944 void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5945 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5946 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5947 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5948 }
VisitPipeTypeLoc(PipeTypeLoc TL)5949 void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
5950 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5951 }
5952
GetTypeSourceInfo(ModuleFile & F,const RecordData & Record,unsigned & Idx)5953 TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
5954 const RecordData &Record,
5955 unsigned &Idx) {
5956 QualType InfoTy = readType(F, Record, Idx);
5957 if (InfoTy.isNull())
5958 return nullptr;
5959
5960 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
5961 TypeLocReader TLR(*this, F, Record, Idx);
5962 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
5963 TLR.Visit(TL);
5964 return TInfo;
5965 }
5966
GetType(TypeID ID)5967 QualType ASTReader::GetType(TypeID ID) {
5968 unsigned FastQuals = ID & Qualifiers::FastMask;
5969 unsigned Index = ID >> Qualifiers::FastWidth;
5970
5971 if (Index < NUM_PREDEF_TYPE_IDS) {
5972 QualType T;
5973 switch ((PredefinedTypeIDs)Index) {
5974 case PREDEF_TYPE_NULL_ID:
5975 return QualType();
5976 case PREDEF_TYPE_VOID_ID:
5977 T = Context.VoidTy;
5978 break;
5979 case PREDEF_TYPE_BOOL_ID:
5980 T = Context.BoolTy;
5981 break;
5982
5983 case PREDEF_TYPE_CHAR_U_ID:
5984 case PREDEF_TYPE_CHAR_S_ID:
5985 // FIXME: Check that the signedness of CharTy is correct!
5986 T = Context.CharTy;
5987 break;
5988
5989 case PREDEF_TYPE_UCHAR_ID:
5990 T = Context.UnsignedCharTy;
5991 break;
5992 case PREDEF_TYPE_USHORT_ID:
5993 T = Context.UnsignedShortTy;
5994 break;
5995 case PREDEF_TYPE_UINT_ID:
5996 T = Context.UnsignedIntTy;
5997 break;
5998 case PREDEF_TYPE_ULONG_ID:
5999 T = Context.UnsignedLongTy;
6000 break;
6001 case PREDEF_TYPE_ULONGLONG_ID:
6002 T = Context.UnsignedLongLongTy;
6003 break;
6004 case PREDEF_TYPE_UINT128_ID:
6005 T = Context.UnsignedInt128Ty;
6006 break;
6007 case PREDEF_TYPE_SCHAR_ID:
6008 T = Context.SignedCharTy;
6009 break;
6010 case PREDEF_TYPE_WCHAR_ID:
6011 T = Context.WCharTy;
6012 break;
6013 case PREDEF_TYPE_SHORT_ID:
6014 T = Context.ShortTy;
6015 break;
6016 case PREDEF_TYPE_INT_ID:
6017 T = Context.IntTy;
6018 break;
6019 case PREDEF_TYPE_LONG_ID:
6020 T = Context.LongTy;
6021 break;
6022 case PREDEF_TYPE_LONGLONG_ID:
6023 T = Context.LongLongTy;
6024 break;
6025 case PREDEF_TYPE_INT128_ID:
6026 T = Context.Int128Ty;
6027 break;
6028 case PREDEF_TYPE_HALF_ID:
6029 T = Context.HalfTy;
6030 break;
6031 case PREDEF_TYPE_FLOAT_ID:
6032 T = Context.FloatTy;
6033 break;
6034 case PREDEF_TYPE_DOUBLE_ID:
6035 T = Context.DoubleTy;
6036 break;
6037 case PREDEF_TYPE_LONGDOUBLE_ID:
6038 T = Context.LongDoubleTy;
6039 break;
6040 case PREDEF_TYPE_FLOAT128_ID:
6041 T = Context.Float128Ty;
6042 break;
6043 case PREDEF_TYPE_OVERLOAD_ID:
6044 T = Context.OverloadTy;
6045 break;
6046 case PREDEF_TYPE_BOUND_MEMBER:
6047 T = Context.BoundMemberTy;
6048 break;
6049 case PREDEF_TYPE_PSEUDO_OBJECT:
6050 T = Context.PseudoObjectTy;
6051 break;
6052 case PREDEF_TYPE_DEPENDENT_ID:
6053 T = Context.DependentTy;
6054 break;
6055 case PREDEF_TYPE_UNKNOWN_ANY:
6056 T = Context.UnknownAnyTy;
6057 break;
6058 case PREDEF_TYPE_NULLPTR_ID:
6059 T = Context.NullPtrTy;
6060 break;
6061 case PREDEF_TYPE_CHAR16_ID:
6062 T = Context.Char16Ty;
6063 break;
6064 case PREDEF_TYPE_CHAR32_ID:
6065 T = Context.Char32Ty;
6066 break;
6067 case PREDEF_TYPE_OBJC_ID:
6068 T = Context.ObjCBuiltinIdTy;
6069 break;
6070 case PREDEF_TYPE_OBJC_CLASS:
6071 T = Context.ObjCBuiltinClassTy;
6072 break;
6073 case PREDEF_TYPE_OBJC_SEL:
6074 T = Context.ObjCBuiltinSelTy;
6075 break;
6076 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6077 case PREDEF_TYPE_##Id##_ID: \
6078 T = Context.SingletonId; \
6079 break;
6080 #include "clang/Basic/OpenCLImageTypes.def"
6081 case PREDEF_TYPE_SAMPLER_ID:
6082 T = Context.OCLSamplerTy;
6083 break;
6084 case PREDEF_TYPE_EVENT_ID:
6085 T = Context.OCLEventTy;
6086 break;
6087 case PREDEF_TYPE_CLK_EVENT_ID:
6088 T = Context.OCLClkEventTy;
6089 break;
6090 case PREDEF_TYPE_QUEUE_ID:
6091 T = Context.OCLQueueTy;
6092 break;
6093 case PREDEF_TYPE_NDRANGE_ID:
6094 T = Context.OCLNDRangeTy;
6095 break;
6096 case PREDEF_TYPE_RESERVE_ID_ID:
6097 T = Context.OCLReserveIDTy;
6098 break;
6099 case PREDEF_TYPE_AUTO_DEDUCT:
6100 T = Context.getAutoDeductType();
6101 break;
6102
6103 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
6104 T = Context.getAutoRRefDeductType();
6105 break;
6106
6107 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
6108 T = Context.ARCUnbridgedCastTy;
6109 break;
6110
6111 case PREDEF_TYPE_BUILTIN_FN:
6112 T = Context.BuiltinFnTy;
6113 break;
6114
6115 case PREDEF_TYPE_OMP_ARRAY_SECTION:
6116 T = Context.OMPArraySectionTy;
6117 break;
6118 }
6119
6120 assert(!T.isNull() && "Unknown predefined type");
6121 return T.withFastQualifiers(FastQuals);
6122 }
6123
6124 Index -= NUM_PREDEF_TYPE_IDS;
6125 assert(Index < TypesLoaded.size() && "Type index out-of-range");
6126 if (TypesLoaded[Index].isNull()) {
6127 TypesLoaded[Index] = readTypeRecord(Index);
6128 if (TypesLoaded[Index].isNull())
6129 return QualType();
6130
6131 TypesLoaded[Index]->setFromAST();
6132 if (DeserializationListener)
6133 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
6134 TypesLoaded[Index]);
6135 }
6136
6137 return TypesLoaded[Index].withFastQualifiers(FastQuals);
6138 }
6139
getLocalType(ModuleFile & F,unsigned LocalID)6140 QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
6141 return GetType(getGlobalTypeID(F, LocalID));
6142 }
6143
6144 serialization::TypeID
getGlobalTypeID(ModuleFile & F,unsigned LocalID) const6145 ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
6146 unsigned FastQuals = LocalID & Qualifiers::FastMask;
6147 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
6148
6149 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
6150 return LocalID;
6151
6152 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6153 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
6154 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
6155
6156 unsigned GlobalIndex = LocalIndex + I->second;
6157 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
6158 }
6159
6160 TemplateArgumentLocInfo
GetTemplateArgumentLocInfo(ModuleFile & F,TemplateArgument::ArgKind Kind,const RecordData & Record,unsigned & Index)6161 ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
6162 TemplateArgument::ArgKind Kind,
6163 const RecordData &Record,
6164 unsigned &Index) {
6165 switch (Kind) {
6166 case TemplateArgument::Expression:
6167 return ReadExpr(F);
6168 case TemplateArgument::Type:
6169 return GetTypeSourceInfo(F, Record, Index);
6170 case TemplateArgument::Template: {
6171 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6172 Index);
6173 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6174 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6175 SourceLocation());
6176 }
6177 case TemplateArgument::TemplateExpansion: {
6178 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6179 Index);
6180 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6181 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6182 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6183 EllipsisLoc);
6184 }
6185 case TemplateArgument::Null:
6186 case TemplateArgument::Integral:
6187 case TemplateArgument::Declaration:
6188 case TemplateArgument::NullPtr:
6189 case TemplateArgument::Pack:
6190 // FIXME: Is this right?
6191 return TemplateArgumentLocInfo();
6192 }
6193 llvm_unreachable("unexpected template argument loc");
6194 }
6195
6196 TemplateArgumentLoc
ReadTemplateArgumentLoc(ModuleFile & F,const RecordData & Record,unsigned & Index)6197 ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
6198 const RecordData &Record, unsigned &Index) {
6199 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6200
6201 if (Arg.getKind() == TemplateArgument::Expression) {
6202 if (Record[Index++]) // bool InfoHasSameExpr.
6203 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
6204 }
6205 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6206 Record, Index));
6207 }
6208
6209 const ASTTemplateArgumentListInfo*
ReadASTTemplateArgumentListInfo(ModuleFile & F,const RecordData & Record,unsigned & Index)6210 ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
6211 const RecordData &Record,
6212 unsigned &Index) {
6213 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6214 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6215 unsigned NumArgsAsWritten = Record[Index++];
6216 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6217 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6218 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6219 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6220 }
6221
GetExternalDecl(uint32_t ID)6222 Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6223 return GetDecl(ID);
6224 }
6225
6226 template<typename TemplateSpecializationDecl>
completeRedeclChainForTemplateSpecialization(Decl * D)6227 static void completeRedeclChainForTemplateSpecialization(Decl *D) {
6228 if (auto *TSD = dyn_cast<TemplateSpecializationDecl>(D))
6229 TSD->getSpecializedTemplate()->LoadLazySpecializations();
6230 }
6231
CompleteRedeclChain(const Decl * D)6232 void ASTReader::CompleteRedeclChain(const Decl *D) {
6233 if (NumCurrentElementsDeserializing) {
6234 // We arrange to not care about the complete redeclaration chain while we're
6235 // deserializing. Just remember that the AST has marked this one as complete
6236 // but that it's not actually complete yet, so we know we still need to
6237 // complete it later.
6238 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6239 return;
6240 }
6241
6242 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6243
6244 // If this is a named declaration, complete it by looking it up
6245 // within its context.
6246 //
6247 // FIXME: Merging a function definition should merge
6248 // all mergeable entities within it.
6249 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6250 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6251 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
6252 if (!getContext().getLangOpts().CPlusPlus &&
6253 isa<TranslationUnitDecl>(DC)) {
6254 // Outside of C++, we don't have a lookup table for the TU, so update
6255 // the identifier instead. (For C++ modules, we don't store decls
6256 // in the serialized identifier table, so we do the lookup in the TU.)
6257 auto *II = Name.getAsIdentifierInfo();
6258 assert(II && "non-identifier name in C?");
6259 if (II->isOutOfDate())
6260 updateOutOfDateIdentifier(*II);
6261 } else
6262 DC->lookup(Name);
6263 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
6264 // Find all declarations of this kind from the relevant context.
6265 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
6266 auto *DC = cast<DeclContext>(DCDecl);
6267 SmallVector<Decl*, 8> Decls;
6268 FindExternalLexicalDecls(
6269 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
6270 }
6271 }
6272 }
6273
6274 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
6275 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
6276 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
6277 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
6278 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6279 if (auto *Template = FD->getPrimaryTemplate())
6280 Template->LoadLazySpecializations();
6281 }
6282 }
6283
6284 CXXCtorInitializer **
GetExternalCXXCtorInitializers(uint64_t Offset)6285 ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
6286 RecordLocation Loc = getLocalBitOffset(Offset);
6287 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6288 SavedStreamPosition SavedPosition(Cursor);
6289 Cursor.JumpToBit(Loc.Offset);
6290 ReadingKindTracker ReadingKind(Read_Decl, *this);
6291
6292 RecordData Record;
6293 unsigned Code = Cursor.ReadCode();
6294 unsigned RecCode = Cursor.readRecord(Code, Record);
6295 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
6296 Error("malformed AST file: missing C++ ctor initializers");
6297 return nullptr;
6298 }
6299
6300 unsigned Idx = 0;
6301 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
6302 }
6303
GetExternalCXXBaseSpecifiers(uint64_t Offset)6304 CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
6305 RecordLocation Loc = getLocalBitOffset(Offset);
6306 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6307 SavedStreamPosition SavedPosition(Cursor);
6308 Cursor.JumpToBit(Loc.Offset);
6309 ReadingKindTracker ReadingKind(Read_Decl, *this);
6310 RecordData Record;
6311 unsigned Code = Cursor.ReadCode();
6312 unsigned RecCode = Cursor.readRecord(Code, Record);
6313 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
6314 Error("malformed AST file: missing C++ base specifiers");
6315 return nullptr;
6316 }
6317
6318 unsigned Idx = 0;
6319 unsigned NumBases = Record[Idx++];
6320 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
6321 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
6322 for (unsigned I = 0; I != NumBases; ++I)
6323 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
6324 return Bases;
6325 }
6326
6327 serialization::DeclID
getGlobalDeclID(ModuleFile & F,LocalDeclID LocalID) const6328 ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
6329 if (LocalID < NUM_PREDEF_DECL_IDS)
6330 return LocalID;
6331
6332 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6333 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
6334 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
6335
6336 return LocalID + I->second;
6337 }
6338
isDeclIDFromModule(serialization::GlobalDeclID ID,ModuleFile & M) const6339 bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
6340 ModuleFile &M) const {
6341 // Predefined decls aren't from any module.
6342 if (ID < NUM_PREDEF_DECL_IDS)
6343 return false;
6344
6345 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
6346 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
6347 }
6348
getOwningModuleFile(const Decl * D)6349 ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
6350 if (!D->isFromASTFile())
6351 return nullptr;
6352 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
6353 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6354 return I->second;
6355 }
6356
getSourceLocationForDeclID(GlobalDeclID ID)6357 SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
6358 if (ID < NUM_PREDEF_DECL_IDS)
6359 return SourceLocation();
6360
6361 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6362
6363 if (Index > DeclsLoaded.size()) {
6364 Error("declaration ID out-of-range for AST file");
6365 return SourceLocation();
6366 }
6367
6368 if (Decl *D = DeclsLoaded[Index])
6369 return D->getLocation();
6370
6371 SourceLocation Loc;
6372 DeclCursorForID(ID, Loc);
6373 return Loc;
6374 }
6375
getPredefinedDecl(ASTContext & Context,PredefinedDeclIDs ID)6376 static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
6377 switch (ID) {
6378 case PREDEF_DECL_NULL_ID:
6379 return nullptr;
6380
6381 case PREDEF_DECL_TRANSLATION_UNIT_ID:
6382 return Context.getTranslationUnitDecl();
6383
6384 case PREDEF_DECL_OBJC_ID_ID:
6385 return Context.getObjCIdDecl();
6386
6387 case PREDEF_DECL_OBJC_SEL_ID:
6388 return Context.getObjCSelDecl();
6389
6390 case PREDEF_DECL_OBJC_CLASS_ID:
6391 return Context.getObjCClassDecl();
6392
6393 case PREDEF_DECL_OBJC_PROTOCOL_ID:
6394 return Context.getObjCProtocolDecl();
6395
6396 case PREDEF_DECL_INT_128_ID:
6397 return Context.getInt128Decl();
6398
6399 case PREDEF_DECL_UNSIGNED_INT_128_ID:
6400 return Context.getUInt128Decl();
6401
6402 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
6403 return Context.getObjCInstanceTypeDecl();
6404
6405 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
6406 return Context.getBuiltinVaListDecl();
6407
6408 case PREDEF_DECL_VA_LIST_TAG:
6409 return Context.getVaListTagDecl();
6410
6411 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
6412 return Context.getBuiltinMSVaListDecl();
6413
6414 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
6415 return Context.getExternCContextDecl();
6416
6417 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
6418 return Context.getMakeIntegerSeqDecl();
6419
6420 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
6421 return Context.getCFConstantStringDecl();
6422
6423 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
6424 return Context.getCFConstantStringTagDecl();
6425
6426 case PREDEF_DECL_TYPE_PACK_ELEMENT_ID:
6427 return Context.getTypePackElementDecl();
6428 }
6429 llvm_unreachable("PredefinedDeclIDs unknown enum value");
6430 }
6431
GetExistingDecl(DeclID ID)6432 Decl *ASTReader::GetExistingDecl(DeclID ID) {
6433 if (ID < NUM_PREDEF_DECL_IDS) {
6434 Decl *D = getPredefinedDecl(Context, (PredefinedDeclIDs)ID);
6435 if (D) {
6436 // Track that we have merged the declaration with ID \p ID into the
6437 // pre-existing predefined declaration \p D.
6438 auto &Merged = KeyDecls[D->getCanonicalDecl()];
6439 if (Merged.empty())
6440 Merged.push_back(ID);
6441 }
6442 return D;
6443 }
6444
6445 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6446
6447 if (Index >= DeclsLoaded.size()) {
6448 assert(0 && "declaration ID out-of-range for AST file");
6449 Error("declaration ID out-of-range for AST file");
6450 return nullptr;
6451 }
6452
6453 return DeclsLoaded[Index];
6454 }
6455
GetDecl(DeclID ID)6456 Decl *ASTReader::GetDecl(DeclID ID) {
6457 if (ID < NUM_PREDEF_DECL_IDS)
6458 return GetExistingDecl(ID);
6459
6460 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6461
6462 if (Index >= DeclsLoaded.size()) {
6463 assert(0 && "declaration ID out-of-range for AST file");
6464 Error("declaration ID out-of-range for AST file");
6465 return nullptr;
6466 }
6467
6468 if (!DeclsLoaded[Index]) {
6469 ReadDeclRecord(ID);
6470 if (DeserializationListener)
6471 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
6472 }
6473
6474 return DeclsLoaded[Index];
6475 }
6476
mapGlobalIDToModuleFileGlobalID(ModuleFile & M,DeclID GlobalID)6477 DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
6478 DeclID GlobalID) {
6479 if (GlobalID < NUM_PREDEF_DECL_IDS)
6480 return GlobalID;
6481
6482 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
6483 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6484 ModuleFile *Owner = I->second;
6485
6486 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
6487 = M.GlobalToLocalDeclIDs.find(Owner);
6488 if (Pos == M.GlobalToLocalDeclIDs.end())
6489 return 0;
6490
6491 return GlobalID - Owner->BaseDeclID + Pos->second;
6492 }
6493
ReadDeclID(ModuleFile & F,const RecordData & Record,unsigned & Idx)6494 serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
6495 const RecordData &Record,
6496 unsigned &Idx) {
6497 if (Idx >= Record.size()) {
6498 Error("Corrupted AST file");
6499 return 0;
6500 }
6501
6502 return getGlobalDeclID(F, Record[Idx++]);
6503 }
6504
6505 /// \brief Resolve the offset of a statement into a statement.
6506 ///
6507 /// This operation will read a new statement from the external
6508 /// source each time it is called, and is meant to be used via a
6509 /// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
GetExternalDeclStmt(uint64_t Offset)6510 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
6511 // Switch case IDs are per Decl.
6512 ClearSwitchCaseIDs();
6513
6514 // Offset here is a global offset across the entire chain.
6515 RecordLocation Loc = getLocalBitOffset(Offset);
6516 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
6517 return ReadStmtFromStream(*Loc.F);
6518 }
6519
FindExternalLexicalDecls(const DeclContext * DC,llvm::function_ref<bool (Decl::Kind)> IsKindWeWant,SmallVectorImpl<Decl * > & Decls)6520 void ASTReader::FindExternalLexicalDecls(
6521 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
6522 SmallVectorImpl<Decl *> &Decls) {
6523 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
6524
6525 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
6526 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
6527 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
6528 auto K = (Decl::Kind)+LexicalDecls[I];
6529 if (!IsKindWeWant(K))
6530 continue;
6531
6532 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
6533
6534 // Don't add predefined declarations to the lexical context more
6535 // than once.
6536 if (ID < NUM_PREDEF_DECL_IDS) {
6537 if (PredefsVisited[ID])
6538 continue;
6539
6540 PredefsVisited[ID] = true;
6541 }
6542
6543 if (Decl *D = GetLocalDecl(*M, ID)) {
6544 assert(D->getKind() == K && "wrong kind for lexical decl");
6545 if (!DC->isDeclInLexicalTraversal(D))
6546 Decls.push_back(D);
6547 }
6548 }
6549 };
6550
6551 if (isa<TranslationUnitDecl>(DC)) {
6552 for (auto Lexical : TULexicalDecls)
6553 Visit(Lexical.first, Lexical.second);
6554 } else {
6555 auto I = LexicalDecls.find(DC);
6556 if (I != LexicalDecls.end())
6557 Visit(I->second.first, I->second.second);
6558 }
6559
6560 ++NumLexicalDeclContextsRead;
6561 }
6562
6563 namespace {
6564
6565 class DeclIDComp {
6566 ASTReader &Reader;
6567 ModuleFile &Mod;
6568
6569 public:
DeclIDComp(ASTReader & Reader,ModuleFile & M)6570 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
6571
operator ()(LocalDeclID L,LocalDeclID R) const6572 bool operator()(LocalDeclID L, LocalDeclID R) const {
6573 SourceLocation LHS = getLocation(L);
6574 SourceLocation RHS = getLocation(R);
6575 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6576 }
6577
operator ()(SourceLocation LHS,LocalDeclID R) const6578 bool operator()(SourceLocation LHS, LocalDeclID R) const {
6579 SourceLocation RHS = getLocation(R);
6580 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6581 }
6582
operator ()(LocalDeclID L,SourceLocation RHS) const6583 bool operator()(LocalDeclID L, SourceLocation RHS) const {
6584 SourceLocation LHS = getLocation(L);
6585 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6586 }
6587
getLocation(LocalDeclID ID) const6588 SourceLocation getLocation(LocalDeclID ID) const {
6589 return Reader.getSourceManager().getFileLoc(
6590 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
6591 }
6592 };
6593
6594 }
6595
FindFileRegionDecls(FileID File,unsigned Offset,unsigned Length,SmallVectorImpl<Decl * > & Decls)6596 void ASTReader::FindFileRegionDecls(FileID File,
6597 unsigned Offset, unsigned Length,
6598 SmallVectorImpl<Decl *> &Decls) {
6599 SourceManager &SM = getSourceManager();
6600
6601 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
6602 if (I == FileDeclIDs.end())
6603 return;
6604
6605 FileDeclsInfo &DInfo = I->second;
6606 if (DInfo.Decls.empty())
6607 return;
6608
6609 SourceLocation
6610 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
6611 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
6612
6613 DeclIDComp DIDComp(*this, *DInfo.Mod);
6614 ArrayRef<serialization::LocalDeclID>::iterator
6615 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6616 BeginLoc, DIDComp);
6617 if (BeginIt != DInfo.Decls.begin())
6618 --BeginIt;
6619
6620 // If we are pointing at a top-level decl inside an objc container, we need
6621 // to backtrack until we find it otherwise we will fail to report that the
6622 // region overlaps with an objc container.
6623 while (BeginIt != DInfo.Decls.begin() &&
6624 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
6625 ->isTopLevelDeclInObjCContainer())
6626 --BeginIt;
6627
6628 ArrayRef<serialization::LocalDeclID>::iterator
6629 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6630 EndLoc, DIDComp);
6631 if (EndIt != DInfo.Decls.end())
6632 ++EndIt;
6633
6634 for (ArrayRef<serialization::LocalDeclID>::iterator
6635 DIt = BeginIt; DIt != EndIt; ++DIt)
6636 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
6637 }
6638
6639 bool
FindExternalVisibleDeclsByName(const DeclContext * DC,DeclarationName Name)6640 ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
6641 DeclarationName Name) {
6642 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
6643 "DeclContext has no visible decls in storage");
6644 if (!Name)
6645 return false;
6646
6647 auto It = Lookups.find(DC);
6648 if (It == Lookups.end())
6649 return false;
6650
6651 Deserializing LookupResults(this);
6652
6653 // Load the list of declarations.
6654 SmallVector<NamedDecl *, 64> Decls;
6655 for (DeclID ID : It->second.Table.find(Name)) {
6656 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6657 if (ND->getDeclName() == Name)
6658 Decls.push_back(ND);
6659 }
6660
6661 ++NumVisibleDeclContextsRead;
6662 SetExternalVisibleDeclsForName(DC, Name, Decls);
6663 return !Decls.empty();
6664 }
6665
completeVisibleDeclsMap(const DeclContext * DC)6666 void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
6667 if (!DC->hasExternalVisibleStorage())
6668 return;
6669
6670 auto It = Lookups.find(DC);
6671 assert(It != Lookups.end() &&
6672 "have external visible storage but no lookup tables");
6673
6674 DeclsMap Decls;
6675
6676 for (DeclID ID : It->second.Table.findAll()) {
6677 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6678 Decls[ND->getDeclName()].push_back(ND);
6679 }
6680
6681 ++NumVisibleDeclContextsRead;
6682
6683 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
6684 SetExternalVisibleDeclsForName(DC, I->first, I->second);
6685 }
6686 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
6687 }
6688
6689 const serialization::reader::DeclContextLookupTable *
getLoadedLookupTables(DeclContext * Primary) const6690 ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
6691 auto I = Lookups.find(Primary);
6692 return I == Lookups.end() ? nullptr : &I->second;
6693 }
6694
6695 /// \brief Under non-PCH compilation the consumer receives the objc methods
6696 /// before receiving the implementation, and codegen depends on this.
6697 /// We simulate this by deserializing and passing to consumer the methods of the
6698 /// implementation before passing the deserialized implementation decl.
PassObjCImplDeclToConsumer(ObjCImplDecl * ImplD,ASTConsumer * Consumer)6699 static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
6700 ASTConsumer *Consumer) {
6701 assert(ImplD && Consumer);
6702
6703 for (auto *I : ImplD->methods())
6704 Consumer->HandleInterestingDecl(DeclGroupRef(I));
6705
6706 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
6707 }
6708
PassInterestingDeclsToConsumer()6709 void ASTReader::PassInterestingDeclsToConsumer() {
6710 assert(Consumer);
6711
6712 if (PassingDeclsToConsumer)
6713 return;
6714
6715 // Guard variable to avoid recursively redoing the process of passing
6716 // decls to consumer.
6717 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
6718 true);
6719
6720 // Ensure that we've loaded all potentially-interesting declarations
6721 // that need to be eagerly loaded.
6722 for (auto ID : EagerlyDeserializedDecls)
6723 GetDecl(ID);
6724 EagerlyDeserializedDecls.clear();
6725
6726 while (!InterestingDecls.empty()) {
6727 Decl *D = InterestingDecls.front();
6728 InterestingDecls.pop_front();
6729
6730 PassInterestingDeclToConsumer(D);
6731 }
6732 }
6733
PassInterestingDeclToConsumer(Decl * D)6734 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
6735 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
6736 PassObjCImplDeclToConsumer(ImplD, Consumer);
6737 else
6738 Consumer->HandleInterestingDecl(DeclGroupRef(D));
6739 }
6740
StartTranslationUnit(ASTConsumer * Consumer)6741 void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
6742 this->Consumer = Consumer;
6743
6744 if (Consumer)
6745 PassInterestingDeclsToConsumer();
6746
6747 if (DeserializationListener)
6748 DeserializationListener->ReaderInitialized(this);
6749 }
6750
PrintStats()6751 void ASTReader::PrintStats() {
6752 std::fprintf(stderr, "*** AST File Statistics:\n");
6753
6754 unsigned NumTypesLoaded
6755 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
6756 QualType());
6757 unsigned NumDeclsLoaded
6758 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
6759 (Decl *)nullptr);
6760 unsigned NumIdentifiersLoaded
6761 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
6762 IdentifiersLoaded.end(),
6763 (IdentifierInfo *)nullptr);
6764 unsigned NumMacrosLoaded
6765 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
6766 MacrosLoaded.end(),
6767 (MacroInfo *)nullptr);
6768 unsigned NumSelectorsLoaded
6769 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
6770 SelectorsLoaded.end(),
6771 Selector());
6772
6773 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
6774 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
6775 NumSLocEntriesRead, TotalNumSLocEntries,
6776 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
6777 if (!TypesLoaded.empty())
6778 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
6779 NumTypesLoaded, (unsigned)TypesLoaded.size(),
6780 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
6781 if (!DeclsLoaded.empty())
6782 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
6783 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
6784 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
6785 if (!IdentifiersLoaded.empty())
6786 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
6787 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
6788 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
6789 if (!MacrosLoaded.empty())
6790 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6791 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
6792 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
6793 if (!SelectorsLoaded.empty())
6794 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
6795 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
6796 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
6797 if (TotalNumStatements)
6798 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
6799 NumStatementsRead, TotalNumStatements,
6800 ((float)NumStatementsRead/TotalNumStatements * 100));
6801 if (TotalNumMacros)
6802 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6803 NumMacrosRead, TotalNumMacros,
6804 ((float)NumMacrosRead/TotalNumMacros * 100));
6805 if (TotalLexicalDeclContexts)
6806 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
6807 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
6808 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
6809 * 100));
6810 if (TotalVisibleDeclContexts)
6811 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
6812 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
6813 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
6814 * 100));
6815 if (TotalNumMethodPoolEntries) {
6816 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
6817 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
6818 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
6819 * 100));
6820 }
6821 if (NumMethodPoolLookups) {
6822 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
6823 NumMethodPoolHits, NumMethodPoolLookups,
6824 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
6825 }
6826 if (NumMethodPoolTableLookups) {
6827 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
6828 NumMethodPoolTableHits, NumMethodPoolTableLookups,
6829 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
6830 * 100.0));
6831 }
6832
6833 if (NumIdentifierLookupHits) {
6834 std::fprintf(stderr,
6835 " %u / %u identifier table lookups succeeded (%f%%)\n",
6836 NumIdentifierLookupHits, NumIdentifierLookups,
6837 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
6838 }
6839
6840 if (GlobalIndex) {
6841 std::fprintf(stderr, "\n");
6842 GlobalIndex->printStats();
6843 }
6844
6845 std::fprintf(stderr, "\n");
6846 dump();
6847 std::fprintf(stderr, "\n");
6848 }
6849
6850 template<typename Key, typename ModuleFile, unsigned InitialCapacity>
6851 static void
dumpModuleIDMap(StringRef Name,const ContinuousRangeMap<Key,ModuleFile *,InitialCapacity> & Map)6852 dumpModuleIDMap(StringRef Name,
6853 const ContinuousRangeMap<Key, ModuleFile *,
6854 InitialCapacity> &Map) {
6855 if (Map.begin() == Map.end())
6856 return;
6857
6858 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
6859 llvm::errs() << Name << ":\n";
6860 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
6861 I != IEnd; ++I) {
6862 llvm::errs() << " " << I->first << " -> " << I->second->FileName
6863 << "\n";
6864 }
6865 }
6866
dump()6867 LLVM_DUMP_METHOD void ASTReader::dump() {
6868 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
6869 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
6870 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
6871 dumpModuleIDMap("Global type map", GlobalTypeMap);
6872 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
6873 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
6874 dumpModuleIDMap("Global macro map", GlobalMacroMap);
6875 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
6876 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
6877 dumpModuleIDMap("Global preprocessed entity map",
6878 GlobalPreprocessedEntityMap);
6879
6880 llvm::errs() << "\n*** PCH/Modules Loaded:";
6881 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
6882 MEnd = ModuleMgr.end();
6883 M != MEnd; ++M)
6884 (*M)->dump();
6885 }
6886
6887 /// Return the amount of memory used by memory buffers, breaking down
6888 /// by heap-backed versus mmap'ed memory.
getMemoryBufferSizes(MemoryBufferSizes & sizes) const6889 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
6890 for (ModuleConstIterator I = ModuleMgr.begin(),
6891 E = ModuleMgr.end(); I != E; ++I) {
6892 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
6893 size_t bytes = buf->getBufferSize();
6894 switch (buf->getBufferKind()) {
6895 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
6896 sizes.malloc_bytes += bytes;
6897 break;
6898 case llvm::MemoryBuffer::MemoryBuffer_MMap:
6899 sizes.mmap_bytes += bytes;
6900 break;
6901 }
6902 }
6903 }
6904 }
6905
InitializeSema(Sema & S)6906 void ASTReader::InitializeSema(Sema &S) {
6907 SemaObj = &S;
6908 S.addExternalSource(this);
6909
6910 // Makes sure any declarations that were deserialized "too early"
6911 // still get added to the identifier's declaration chains.
6912 for (uint64_t ID : PreloadedDeclIDs) {
6913 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
6914 pushExternalDeclIntoScope(D, D->getDeclName());
6915 }
6916 PreloadedDeclIDs.clear();
6917
6918 // FIXME: What happens if these are changed by a module import?
6919 if (!FPPragmaOptions.empty()) {
6920 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
6921 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
6922 }
6923
6924 // FIXME: What happens if these are changed by a module import?
6925 if (!OpenCLExtensions.empty()) {
6926 unsigned I = 0;
6927 #define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
6928 #include "clang/Basic/OpenCLExtensions.def"
6929
6930 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
6931 }
6932
6933 UpdateSema();
6934 }
6935
UpdateSema()6936 void ASTReader::UpdateSema() {
6937 assert(SemaObj && "no Sema to update");
6938
6939 // Load the offsets of the declarations that Sema references.
6940 // They will be lazily deserialized when needed.
6941 if (!SemaDeclRefs.empty()) {
6942 assert(SemaDeclRefs.size() % 2 == 0);
6943 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) {
6944 if (!SemaObj->StdNamespace)
6945 SemaObj->StdNamespace = SemaDeclRefs[I];
6946 if (!SemaObj->StdBadAlloc)
6947 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
6948 }
6949 SemaDeclRefs.clear();
6950 }
6951
6952 // Update the state of pragmas. Use the same API as if we had encountered the
6953 // pragma in the source.
6954 if(OptimizeOffPragmaLocation.isValid())
6955 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
6956 if (PragmaMSStructState != -1)
6957 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
6958 if (PointersToMembersPragmaLocation.isValid()) {
6959 SemaObj->ActOnPragmaMSPointersToMembers(
6960 (LangOptions::PragmaMSPointersToMembersKind)
6961 PragmaMSPointersToMembersState,
6962 PointersToMembersPragmaLocation);
6963 }
6964 }
6965
get(StringRef Name)6966 IdentifierInfo *ASTReader::get(StringRef Name) {
6967 // Note that we are loading an identifier.
6968 Deserializing AnIdentifier(this);
6969
6970 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
6971 NumIdentifierLookups,
6972 NumIdentifierLookupHits);
6973
6974 // We don't need to do identifier table lookups in C++ modules (we preload
6975 // all interesting declarations, and don't need to use the scope for name
6976 // lookups). Perform the lookup in PCH files, though, since we don't build
6977 // a complete initial identifier table if we're carrying on from a PCH.
6978 if (Context.getLangOpts().CPlusPlus) {
6979 for (auto F : ModuleMgr.pch_modules())
6980 if (Visitor(*F))
6981 break;
6982 } else {
6983 // If there is a global index, look there first to determine which modules
6984 // provably do not have any results for this identifier.
6985 GlobalModuleIndex::HitSet Hits;
6986 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
6987 if (!loadGlobalIndex()) {
6988 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
6989 HitsPtr = &Hits;
6990 }
6991 }
6992
6993 ModuleMgr.visit(Visitor, HitsPtr);
6994 }
6995
6996 IdentifierInfo *II = Visitor.getIdentifierInfo();
6997 markIdentifierUpToDate(II);
6998 return II;
6999 }
7000
7001 namespace clang {
7002 /// \brief An identifier-lookup iterator that enumerates all of the
7003 /// identifiers stored within a set of AST files.
7004 class ASTIdentifierIterator : public IdentifierIterator {
7005 /// \brief The AST reader whose identifiers are being enumerated.
7006 const ASTReader &Reader;
7007
7008 /// \brief The current index into the chain of AST files stored in
7009 /// the AST reader.
7010 unsigned Index;
7011
7012 /// \brief The current position within the identifier lookup table
7013 /// of the current AST file.
7014 ASTIdentifierLookupTable::key_iterator Current;
7015
7016 /// \brief The end position within the identifier lookup table of
7017 /// the current AST file.
7018 ASTIdentifierLookupTable::key_iterator End;
7019
7020 /// \brief Whether to skip any modules in the ASTReader.
7021 bool SkipModules;
7022
7023 public:
7024 explicit ASTIdentifierIterator(const ASTReader &Reader,
7025 bool SkipModules = false);
7026
7027 StringRef Next() override;
7028 };
7029 }
7030
ASTIdentifierIterator(const ASTReader & Reader,bool SkipModules)7031 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader,
7032 bool SkipModules)
7033 : Reader(Reader), Index(Reader.ModuleMgr.size()), SkipModules(SkipModules) {
7034 }
7035
Next()7036 StringRef ASTIdentifierIterator::Next() {
7037 while (Current == End) {
7038 // If we have exhausted all of our AST files, we're done.
7039 if (Index == 0)
7040 return StringRef();
7041
7042 --Index;
7043 ModuleFile &F = Reader.ModuleMgr[Index];
7044 if (SkipModules && F.isModule())
7045 continue;
7046
7047 ASTIdentifierLookupTable *IdTable =
7048 (ASTIdentifierLookupTable *)F.IdentifierLookupTable;
7049 Current = IdTable->key_begin();
7050 End = IdTable->key_end();
7051 }
7052
7053 // We have any identifiers remaining in the current AST file; return
7054 // the next one.
7055 StringRef Result = *Current;
7056 ++Current;
7057 return Result;
7058 }
7059
7060 namespace {
7061 /// A utility for appending two IdentifierIterators.
7062 class ChainedIdentifierIterator : public IdentifierIterator {
7063 std::unique_ptr<IdentifierIterator> Current;
7064 std::unique_ptr<IdentifierIterator> Queued;
7065
7066 public:
ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,std::unique_ptr<IdentifierIterator> Second)7067 ChainedIdentifierIterator(std::unique_ptr<IdentifierIterator> First,
7068 std::unique_ptr<IdentifierIterator> Second)
7069 : Current(std::move(First)), Queued(std::move(Second)) {}
7070
Next()7071 StringRef Next() override {
7072 if (!Current)
7073 return StringRef();
7074
7075 StringRef result = Current->Next();
7076 if (!result.empty())
7077 return result;
7078
7079 // Try the queued iterator, which may itself be empty.
7080 Current.reset();
7081 std::swap(Current, Queued);
7082 return Next();
7083 }
7084 };
7085 } // end anonymous namespace.
7086
getIdentifiers()7087 IdentifierIterator *ASTReader::getIdentifiers() {
7088 if (!loadGlobalIndex()) {
7089 std::unique_ptr<IdentifierIterator> ReaderIter(
7090 new ASTIdentifierIterator(*this, /*SkipModules=*/true));
7091 std::unique_ptr<IdentifierIterator> ModulesIter(
7092 GlobalIndex->createIdentifierIterator());
7093 return new ChainedIdentifierIterator(std::move(ReaderIter),
7094 std::move(ModulesIter));
7095 }
7096
7097 return new ASTIdentifierIterator(*this);
7098 }
7099
7100 namespace clang { namespace serialization {
7101 class ReadMethodPoolVisitor {
7102 ASTReader &Reader;
7103 Selector Sel;
7104 unsigned PriorGeneration;
7105 unsigned InstanceBits;
7106 unsigned FactoryBits;
7107 bool InstanceHasMoreThanOneDecl;
7108 bool FactoryHasMoreThanOneDecl;
7109 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7110 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
7111
7112 public:
ReadMethodPoolVisitor(ASTReader & Reader,Selector Sel,unsigned PriorGeneration)7113 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
7114 unsigned PriorGeneration)
7115 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
7116 InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false),
7117 FactoryHasMoreThanOneDecl(false) {}
7118
operator ()(ModuleFile & M)7119 bool operator()(ModuleFile &M) {
7120 if (!M.SelectorLookupTable)
7121 return false;
7122
7123 // If we've already searched this module file, skip it now.
7124 if (M.Generation <= PriorGeneration)
7125 return true;
7126
7127 ++Reader.NumMethodPoolTableLookups;
7128 ASTSelectorLookupTable *PoolTable
7129 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
7130 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
7131 if (Pos == PoolTable->end())
7132 return false;
7133
7134 ++Reader.NumMethodPoolTableHits;
7135 ++Reader.NumSelectorsRead;
7136 // FIXME: Not quite happy with the statistics here. We probably should
7137 // disable this tracking when called via LoadSelector.
7138 // Also, should entries without methods count as misses?
7139 ++Reader.NumMethodPoolEntriesRead;
7140 ASTSelectorLookupTrait::data_type Data = *Pos;
7141 if (Reader.DeserializationListener)
7142 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
7143
7144 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7145 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7146 InstanceBits = Data.InstanceBits;
7147 FactoryBits = Data.FactoryBits;
7148 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
7149 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
7150 return true;
7151 }
7152
7153 /// \brief Retrieve the instance methods found by this visitor.
getInstanceMethods() const7154 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
7155 return InstanceMethods;
7156 }
7157
7158 /// \brief Retrieve the instance methods found by this visitor.
getFactoryMethods() const7159 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
7160 return FactoryMethods;
7161 }
7162
getInstanceBits() const7163 unsigned getInstanceBits() const { return InstanceBits; }
getFactoryBits() const7164 unsigned getFactoryBits() const { return FactoryBits; }
instanceHasMoreThanOneDecl() const7165 bool instanceHasMoreThanOneDecl() const {
7166 return InstanceHasMoreThanOneDecl;
7167 }
factoryHasMoreThanOneDecl() const7168 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
7169 };
7170 } } // end namespace clang::serialization
7171
7172 /// \brief Add the given set of methods to the method list.
addMethodsToPool(Sema & S,ArrayRef<ObjCMethodDecl * > Methods,ObjCMethodList & List)7173 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
7174 ObjCMethodList &List) {
7175 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7176 S.addMethodToGlobalList(&List, Methods[I]);
7177 }
7178 }
7179
ReadMethodPool(Selector Sel)7180 void ASTReader::ReadMethodPool(Selector Sel) {
7181 // Get the selector generation and update it to the current generation.
7182 unsigned &Generation = SelectorGeneration[Sel];
7183 unsigned PriorGeneration = Generation;
7184 Generation = getGeneration();
7185 SelectorOutOfDate[Sel] = false;
7186
7187 // Search for methods defined with this selector.
7188 ++NumMethodPoolLookups;
7189 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
7190 ModuleMgr.visit(Visitor);
7191
7192 if (Visitor.getInstanceMethods().empty() &&
7193 Visitor.getFactoryMethods().empty())
7194 return;
7195
7196 ++NumMethodPoolHits;
7197
7198 if (!getSema())
7199 return;
7200
7201 Sema &S = *getSema();
7202 Sema::GlobalMethodPool::iterator Pos
7203 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
7204
7205 Pos->second.first.setBits(Visitor.getInstanceBits());
7206 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
7207 Pos->second.second.setBits(Visitor.getFactoryBits());
7208 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
7209
7210 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
7211 // when building a module we keep every method individually and may need to
7212 // update hasMoreThanOneDecl as we add the methods.
7213 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7214 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
7215 }
7216
updateOutOfDateSelector(Selector Sel)7217 void ASTReader::updateOutOfDateSelector(Selector Sel) {
7218 if (SelectorOutOfDate[Sel])
7219 ReadMethodPool(Sel);
7220 }
7221
ReadKnownNamespaces(SmallVectorImpl<NamespaceDecl * > & Namespaces)7222 void ASTReader::ReadKnownNamespaces(
7223 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7224 Namespaces.clear();
7225
7226 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7227 if (NamespaceDecl *Namespace
7228 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7229 Namespaces.push_back(Namespace);
7230 }
7231 }
7232
ReadUndefinedButUsed(llvm::MapVector<NamedDecl *,SourceLocation> & Undefined)7233 void ASTReader::ReadUndefinedButUsed(
7234 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
7235 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7236 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
7237 SourceLocation Loc =
7238 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
7239 Undefined.insert(std::make_pair(D, Loc));
7240 }
7241 }
7242
ReadMismatchingDeleteExpressions(llvm::MapVector<FieldDecl *,llvm::SmallVector<std::pair<SourceLocation,bool>,4>> & Exprs)7243 void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
7244 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
7245 Exprs) {
7246 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
7247 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
7248 uint64_t Count = DelayedDeleteExprs[Idx++];
7249 for (uint64_t C = 0; C < Count; ++C) {
7250 SourceLocation DeleteLoc =
7251 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
7252 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
7253 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
7254 }
7255 }
7256 }
7257
ReadTentativeDefinitions(SmallVectorImpl<VarDecl * > & TentativeDefs)7258 void ASTReader::ReadTentativeDefinitions(
7259 SmallVectorImpl<VarDecl *> &TentativeDefs) {
7260 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
7261 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
7262 if (Var)
7263 TentativeDefs.push_back(Var);
7264 }
7265 TentativeDefinitions.clear();
7266 }
7267
ReadUnusedFileScopedDecls(SmallVectorImpl<const DeclaratorDecl * > & Decls)7268 void ASTReader::ReadUnusedFileScopedDecls(
7269 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
7270 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
7271 DeclaratorDecl *D
7272 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
7273 if (D)
7274 Decls.push_back(D);
7275 }
7276 UnusedFileScopedDecls.clear();
7277 }
7278
ReadDelegatingConstructors(SmallVectorImpl<CXXConstructorDecl * > & Decls)7279 void ASTReader::ReadDelegatingConstructors(
7280 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
7281 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
7282 CXXConstructorDecl *D
7283 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
7284 if (D)
7285 Decls.push_back(D);
7286 }
7287 DelegatingCtorDecls.clear();
7288 }
7289
ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl * > & Decls)7290 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
7291 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
7292 TypedefNameDecl *D
7293 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
7294 if (D)
7295 Decls.push_back(D);
7296 }
7297 ExtVectorDecls.clear();
7298 }
7299
ReadUnusedLocalTypedefNameCandidates(llvm::SmallSetVector<const TypedefNameDecl *,4> & Decls)7300 void ASTReader::ReadUnusedLocalTypedefNameCandidates(
7301 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
7302 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
7303 ++I) {
7304 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
7305 GetDecl(UnusedLocalTypedefNameCandidates[I]));
7306 if (D)
7307 Decls.insert(D);
7308 }
7309 UnusedLocalTypedefNameCandidates.clear();
7310 }
7311
ReadReferencedSelectors(SmallVectorImpl<std::pair<Selector,SourceLocation>> & Sels)7312 void ASTReader::ReadReferencedSelectors(
7313 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7314 if (ReferencedSelectorsData.empty())
7315 return;
7316
7317 // If there are @selector references added them to its pool. This is for
7318 // implementation of -Wselector.
7319 unsigned int DataSize = ReferencedSelectorsData.size()-1;
7320 unsigned I = 0;
7321 while (I < DataSize) {
7322 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7323 SourceLocation SelLoc
7324 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7325 Sels.push_back(std::make_pair(Sel, SelLoc));
7326 }
7327 ReferencedSelectorsData.clear();
7328 }
7329
ReadWeakUndeclaredIdentifiers(SmallVectorImpl<std::pair<IdentifierInfo *,WeakInfo>> & WeakIDs)7330 void ASTReader::ReadWeakUndeclaredIdentifiers(
7331 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7332 if (WeakUndeclaredIdentifiers.empty())
7333 return;
7334
7335 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7336 IdentifierInfo *WeakId
7337 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7338 IdentifierInfo *AliasId
7339 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7340 SourceLocation Loc
7341 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7342 bool Used = WeakUndeclaredIdentifiers[I++];
7343 WeakInfo WI(AliasId, Loc);
7344 WI.setUsed(Used);
7345 WeakIDs.push_back(std::make_pair(WeakId, WI));
7346 }
7347 WeakUndeclaredIdentifiers.clear();
7348 }
7349
ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> & VTables)7350 void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
7351 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7352 ExternalVTableUse VT;
7353 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7354 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7355 VT.DefinitionRequired = VTableUses[Idx++];
7356 VTables.push_back(VT);
7357 }
7358
7359 VTableUses.clear();
7360 }
7361
ReadPendingInstantiations(SmallVectorImpl<std::pair<ValueDecl *,SourceLocation>> & Pending)7362 void ASTReader::ReadPendingInstantiations(
7363 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
7364 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
7365 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
7366 SourceLocation Loc
7367 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
7368
7369 Pending.push_back(std::make_pair(D, Loc));
7370 }
7371 PendingInstantiations.clear();
7372 }
7373
ReadLateParsedTemplates(llvm::MapVector<const FunctionDecl *,LateParsedTemplate * > & LPTMap)7374 void ASTReader::ReadLateParsedTemplates(
7375 llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
7376 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
7377 /* In loop */) {
7378 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
7379
7380 LateParsedTemplate *LT = new LateParsedTemplate;
7381 LT->D = GetDecl(LateParsedTemplates[Idx++]);
7382
7383 ModuleFile *F = getOwningModuleFile(LT->D);
7384 assert(F && "No module");
7385
7386 unsigned TokN = LateParsedTemplates[Idx++];
7387 LT->Toks.reserve(TokN);
7388 for (unsigned T = 0; T < TokN; ++T)
7389 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
7390
7391 LPTMap.insert(std::make_pair(FD, LT));
7392 }
7393
7394 LateParsedTemplates.clear();
7395 }
7396
LoadSelector(Selector Sel)7397 void ASTReader::LoadSelector(Selector Sel) {
7398 // It would be complicated to avoid reading the methods anyway. So don't.
7399 ReadMethodPool(Sel);
7400 }
7401
SetIdentifierInfo(IdentifierID ID,IdentifierInfo * II)7402 void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
7403 assert(ID && "Non-zero identifier ID required");
7404 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
7405 IdentifiersLoaded[ID - 1] = II;
7406 if (DeserializationListener)
7407 DeserializationListener->IdentifierRead(ID, II);
7408 }
7409
7410 /// \brief Set the globally-visible declarations associated with the given
7411 /// identifier.
7412 ///
7413 /// If the AST reader is currently in a state where the given declaration IDs
7414 /// cannot safely be resolved, they are queued until it is safe to resolve
7415 /// them.
7416 ///
7417 /// \param II an IdentifierInfo that refers to one or more globally-visible
7418 /// declarations.
7419 ///
7420 /// \param DeclIDs the set of declaration IDs with the name @p II that are
7421 /// visible at global scope.
7422 ///
7423 /// \param Decls if non-null, this vector will be populated with the set of
7424 /// deserialized declarations. These declarations will not be pushed into
7425 /// scope.
7426 void
SetGloballyVisibleDecls(IdentifierInfo * II,const SmallVectorImpl<uint32_t> & DeclIDs,SmallVectorImpl<Decl * > * Decls)7427 ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
7428 const SmallVectorImpl<uint32_t> &DeclIDs,
7429 SmallVectorImpl<Decl *> *Decls) {
7430 if (NumCurrentElementsDeserializing && !Decls) {
7431 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
7432 return;
7433 }
7434
7435 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
7436 if (!SemaObj) {
7437 // Queue this declaration so that it will be added to the
7438 // translation unit scope and identifier's declaration chain
7439 // once a Sema object is known.
7440 PreloadedDeclIDs.push_back(DeclIDs[I]);
7441 continue;
7442 }
7443
7444 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
7445
7446 // If we're simply supposed to record the declarations, do so now.
7447 if (Decls) {
7448 Decls->push_back(D);
7449 continue;
7450 }
7451
7452 // Introduce this declaration into the translation-unit scope
7453 // and add it to the declaration chain for this identifier, so
7454 // that (unqualified) name lookup will find it.
7455 pushExternalDeclIntoScope(D, II);
7456 }
7457 }
7458
DecodeIdentifierInfo(IdentifierID ID)7459 IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
7460 if (ID == 0)
7461 return nullptr;
7462
7463 if (IdentifiersLoaded.empty()) {
7464 Error("no identifier table in AST file");
7465 return nullptr;
7466 }
7467
7468 ID -= 1;
7469 if (!IdentifiersLoaded[ID]) {
7470 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
7471 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
7472 ModuleFile *M = I->second;
7473 unsigned Index = ID - M->BaseIdentifierID;
7474 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
7475
7476 // All of the strings in the AST file are preceded by a 16-bit length.
7477 // Extract that 16-bit length to avoid having to execute strlen().
7478 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
7479 // unsigned integers. This is important to avoid integer overflow when
7480 // we cast them to 'unsigned'.
7481 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
7482 unsigned StrLen = (((unsigned) StrLenPtr[0])
7483 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
7484 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
7485 IdentifiersLoaded[ID] = &II;
7486 markIdentifierFromAST(*this, II);
7487 if (DeserializationListener)
7488 DeserializationListener->IdentifierRead(ID + 1, &II);
7489 }
7490
7491 return IdentifiersLoaded[ID];
7492 }
7493
getLocalIdentifier(ModuleFile & M,unsigned LocalID)7494 IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
7495 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
7496 }
7497
getGlobalIdentifierID(ModuleFile & M,unsigned LocalID)7498 IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
7499 if (LocalID < NUM_PREDEF_IDENT_IDS)
7500 return LocalID;
7501
7502 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7503 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
7504 assert(I != M.IdentifierRemap.end()
7505 && "Invalid index into identifier index remap");
7506
7507 return LocalID + I->second;
7508 }
7509
getMacro(MacroID ID)7510 MacroInfo *ASTReader::getMacro(MacroID ID) {
7511 if (ID == 0)
7512 return nullptr;
7513
7514 if (MacrosLoaded.empty()) {
7515 Error("no macro table in AST file");
7516 return nullptr;
7517 }
7518
7519 ID -= NUM_PREDEF_MACRO_IDS;
7520 if (!MacrosLoaded[ID]) {
7521 GlobalMacroMapType::iterator I
7522 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
7523 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
7524 ModuleFile *M = I->second;
7525 unsigned Index = ID - M->BaseMacroID;
7526 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
7527
7528 if (DeserializationListener)
7529 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
7530 MacrosLoaded[ID]);
7531 }
7532
7533 return MacrosLoaded[ID];
7534 }
7535
getGlobalMacroID(ModuleFile & M,unsigned LocalID)7536 MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
7537 if (LocalID < NUM_PREDEF_MACRO_IDS)
7538 return LocalID;
7539
7540 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7541 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
7542 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
7543
7544 return LocalID + I->second;
7545 }
7546
7547 serialization::SubmoduleID
getGlobalSubmoduleID(ModuleFile & M,unsigned LocalID)7548 ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
7549 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
7550 return LocalID;
7551
7552 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7553 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
7554 assert(I != M.SubmoduleRemap.end()
7555 && "Invalid index into submodule index remap");
7556
7557 return LocalID + I->second;
7558 }
7559
getSubmodule(SubmoduleID GlobalID)7560 Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
7561 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
7562 assert(GlobalID == 0 && "Unhandled global submodule ID");
7563 return nullptr;
7564 }
7565
7566 if (GlobalID > SubmodulesLoaded.size()) {
7567 Error("submodule ID out of range in AST file");
7568 return nullptr;
7569 }
7570
7571 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
7572 }
7573
getModule(unsigned ID)7574 Module *ASTReader::getModule(unsigned ID) {
7575 return getSubmodule(ID);
7576 }
7577
getLocalModuleFile(ModuleFile & F,unsigned ID)7578 ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
7579 if (ID & 1) {
7580 // It's a module, look it up by submodule ID.
7581 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
7582 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
7583 } else {
7584 // It's a prefix (preamble, PCH, ...). Look it up by index.
7585 unsigned IndexFromEnd = ID >> 1;
7586 assert(IndexFromEnd && "got reference to unknown module file");
7587 return getModuleManager().pch_modules().end()[-IndexFromEnd];
7588 }
7589 }
7590
getModuleFileID(ModuleFile * F)7591 unsigned ASTReader::getModuleFileID(ModuleFile *F) {
7592 if (!F)
7593 return 1;
7594
7595 // For a file representing a module, use the submodule ID of the top-level
7596 // module as the file ID. For any other kind of file, the number of such
7597 // files loaded beforehand will be the same on reload.
7598 // FIXME: Is this true even if we have an explicit module file and a PCH?
7599 if (F->isModule())
7600 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
7601
7602 auto PCHModules = getModuleManager().pch_modules();
7603 auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
7604 assert(I != PCHModules.end() && "emitting reference to unknown file");
7605 return (I - PCHModules.end()) << 1;
7606 }
7607
7608 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
getSourceDescriptor(unsigned ID)7609 ASTReader::getSourceDescriptor(unsigned ID) {
7610 if (const Module *M = getSubmodule(ID))
7611 return ExternalASTSource::ASTSourceDescriptor(*M);
7612
7613 // If there is only a single PCH, return it instead.
7614 // Chained PCH are not suported.
7615 if (ModuleMgr.size() == 1) {
7616 ModuleFile &MF = ModuleMgr.getPrimaryModule();
7617 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
7618 StringRef FileName = llvm::sys::path::filename(MF.FileName);
7619 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir, FileName,
7620 MF.Signature);
7621 }
7622 return None;
7623 }
7624
getLocalSelector(ModuleFile & M,unsigned LocalID)7625 Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
7626 return DecodeSelector(getGlobalSelectorID(M, LocalID));
7627 }
7628
DecodeSelector(serialization::SelectorID ID)7629 Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
7630 if (ID == 0)
7631 return Selector();
7632
7633 if (ID > SelectorsLoaded.size()) {
7634 Error("selector ID out of range in AST file");
7635 return Selector();
7636 }
7637
7638 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
7639 // Load this selector from the selector table.
7640 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
7641 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
7642 ModuleFile &M = *I->second;
7643 ASTSelectorLookupTrait Trait(*this, M);
7644 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
7645 SelectorsLoaded[ID - 1] =
7646 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
7647 if (DeserializationListener)
7648 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
7649 }
7650
7651 return SelectorsLoaded[ID - 1];
7652 }
7653
GetExternalSelector(serialization::SelectorID ID)7654 Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
7655 return DecodeSelector(ID);
7656 }
7657
GetNumExternalSelectors()7658 uint32_t ASTReader::GetNumExternalSelectors() {
7659 // ID 0 (the null selector) is considered an external selector.
7660 return getTotalNumSelectors() + 1;
7661 }
7662
7663 serialization::SelectorID
getGlobalSelectorID(ModuleFile & M,unsigned LocalID) const7664 ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
7665 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
7666 return LocalID;
7667
7668 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7669 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
7670 assert(I != M.SelectorRemap.end()
7671 && "Invalid index into selector index remap");
7672
7673 return LocalID + I->second;
7674 }
7675
7676 DeclarationName
ReadDeclarationName(ModuleFile & F,const RecordData & Record,unsigned & Idx)7677 ASTReader::ReadDeclarationName(ModuleFile &F,
7678 const RecordData &Record, unsigned &Idx) {
7679 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
7680 switch (Kind) {
7681 case DeclarationName::Identifier:
7682 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
7683
7684 case DeclarationName::ObjCZeroArgSelector:
7685 case DeclarationName::ObjCOneArgSelector:
7686 case DeclarationName::ObjCMultiArgSelector:
7687 return DeclarationName(ReadSelector(F, Record, Idx));
7688
7689 case DeclarationName::CXXConstructorName:
7690 return Context.DeclarationNames.getCXXConstructorName(
7691 Context.getCanonicalType(readType(F, Record, Idx)));
7692
7693 case DeclarationName::CXXDestructorName:
7694 return Context.DeclarationNames.getCXXDestructorName(
7695 Context.getCanonicalType(readType(F, Record, Idx)));
7696
7697 case DeclarationName::CXXConversionFunctionName:
7698 return Context.DeclarationNames.getCXXConversionFunctionName(
7699 Context.getCanonicalType(readType(F, Record, Idx)));
7700
7701 case DeclarationName::CXXOperatorName:
7702 return Context.DeclarationNames.getCXXOperatorName(
7703 (OverloadedOperatorKind)Record[Idx++]);
7704
7705 case DeclarationName::CXXLiteralOperatorName:
7706 return Context.DeclarationNames.getCXXLiteralOperatorName(
7707 GetIdentifierInfo(F, Record, Idx));
7708
7709 case DeclarationName::CXXUsingDirective:
7710 return DeclarationName::getUsingDirectiveName();
7711 }
7712
7713 llvm_unreachable("Invalid NameKind!");
7714 }
7715
ReadDeclarationNameLoc(ModuleFile & F,DeclarationNameLoc & DNLoc,DeclarationName Name,const RecordData & Record,unsigned & Idx)7716 void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
7717 DeclarationNameLoc &DNLoc,
7718 DeclarationName Name,
7719 const RecordData &Record, unsigned &Idx) {
7720 switch (Name.getNameKind()) {
7721 case DeclarationName::CXXConstructorName:
7722 case DeclarationName::CXXDestructorName:
7723 case DeclarationName::CXXConversionFunctionName:
7724 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
7725 break;
7726
7727 case DeclarationName::CXXOperatorName:
7728 DNLoc.CXXOperatorName.BeginOpNameLoc
7729 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7730 DNLoc.CXXOperatorName.EndOpNameLoc
7731 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7732 break;
7733
7734 case DeclarationName::CXXLiteralOperatorName:
7735 DNLoc.CXXLiteralOperatorName.OpNameLoc
7736 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7737 break;
7738
7739 case DeclarationName::Identifier:
7740 case DeclarationName::ObjCZeroArgSelector:
7741 case DeclarationName::ObjCOneArgSelector:
7742 case DeclarationName::ObjCMultiArgSelector:
7743 case DeclarationName::CXXUsingDirective:
7744 break;
7745 }
7746 }
7747
ReadDeclarationNameInfo(ModuleFile & F,DeclarationNameInfo & NameInfo,const RecordData & Record,unsigned & Idx)7748 void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
7749 DeclarationNameInfo &NameInfo,
7750 const RecordData &Record, unsigned &Idx) {
7751 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
7752 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
7753 DeclarationNameLoc DNLoc;
7754 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
7755 NameInfo.setInfo(DNLoc);
7756 }
7757
ReadQualifierInfo(ModuleFile & F,QualifierInfo & Info,const RecordData & Record,unsigned & Idx)7758 void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
7759 const RecordData &Record, unsigned &Idx) {
7760 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
7761 unsigned NumTPLists = Record[Idx++];
7762 Info.NumTemplParamLists = NumTPLists;
7763 if (NumTPLists) {
7764 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
7765 for (unsigned i=0; i != NumTPLists; ++i)
7766 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
7767 }
7768 }
7769
7770 TemplateName
ReadTemplateName(ModuleFile & F,const RecordData & Record,unsigned & Idx)7771 ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
7772 unsigned &Idx) {
7773 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
7774 switch (Kind) {
7775 case TemplateName::Template:
7776 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
7777
7778 case TemplateName::OverloadedTemplate: {
7779 unsigned size = Record[Idx++];
7780 UnresolvedSet<8> Decls;
7781 while (size--)
7782 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
7783
7784 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
7785 }
7786
7787 case TemplateName::QualifiedTemplate: {
7788 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7789 bool hasTemplKeyword = Record[Idx++];
7790 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
7791 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
7792 }
7793
7794 case TemplateName::DependentTemplate: {
7795 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7796 if (Record[Idx++]) // isIdentifier
7797 return Context.getDependentTemplateName(NNS,
7798 GetIdentifierInfo(F, Record,
7799 Idx));
7800 return Context.getDependentTemplateName(NNS,
7801 (OverloadedOperatorKind)Record[Idx++]);
7802 }
7803
7804 case TemplateName::SubstTemplateTemplateParm: {
7805 TemplateTemplateParmDecl *param
7806 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7807 if (!param) return TemplateName();
7808 TemplateName replacement = ReadTemplateName(F, Record, Idx);
7809 return Context.getSubstTemplateTemplateParm(param, replacement);
7810 }
7811
7812 case TemplateName::SubstTemplateTemplateParmPack: {
7813 TemplateTemplateParmDecl *Param
7814 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7815 if (!Param)
7816 return TemplateName();
7817
7818 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
7819 if (ArgPack.getKind() != TemplateArgument::Pack)
7820 return TemplateName();
7821
7822 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
7823 }
7824 }
7825
7826 llvm_unreachable("Unhandled template name kind!");
7827 }
7828
ReadTemplateArgument(ModuleFile & F,const RecordData & Record,unsigned & Idx,bool Canonicalize)7829 TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
7830 const RecordData &Record,
7831 unsigned &Idx,
7832 bool Canonicalize) {
7833 if (Canonicalize) {
7834 // The caller wants a canonical template argument. Sometimes the AST only
7835 // wants template arguments in canonical form (particularly as the template
7836 // argument lists of template specializations) so ensure we preserve that
7837 // canonical form across serialization.
7838 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
7839 return Context.getCanonicalTemplateArgument(Arg);
7840 }
7841
7842 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
7843 switch (Kind) {
7844 case TemplateArgument::Null:
7845 return TemplateArgument();
7846 case TemplateArgument::Type:
7847 return TemplateArgument(readType(F, Record, Idx));
7848 case TemplateArgument::Declaration: {
7849 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
7850 return TemplateArgument(D, readType(F, Record, Idx));
7851 }
7852 case TemplateArgument::NullPtr:
7853 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
7854 case TemplateArgument::Integral: {
7855 llvm::APSInt Value = ReadAPSInt(Record, Idx);
7856 QualType T = readType(F, Record, Idx);
7857 return TemplateArgument(Context, Value, T);
7858 }
7859 case TemplateArgument::Template:
7860 return TemplateArgument(ReadTemplateName(F, Record, Idx));
7861 case TemplateArgument::TemplateExpansion: {
7862 TemplateName Name = ReadTemplateName(F, Record, Idx);
7863 Optional<unsigned> NumTemplateExpansions;
7864 if (unsigned NumExpansions = Record[Idx++])
7865 NumTemplateExpansions = NumExpansions - 1;
7866 return TemplateArgument(Name, NumTemplateExpansions);
7867 }
7868 case TemplateArgument::Expression:
7869 return TemplateArgument(ReadExpr(F));
7870 case TemplateArgument::Pack: {
7871 unsigned NumArgs = Record[Idx++];
7872 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
7873 for (unsigned I = 0; I != NumArgs; ++I)
7874 Args[I] = ReadTemplateArgument(F, Record, Idx);
7875 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
7876 }
7877 }
7878
7879 llvm_unreachable("Unhandled template argument kind!");
7880 }
7881
7882 TemplateParameterList *
ReadTemplateParameterList(ModuleFile & F,const RecordData & Record,unsigned & Idx)7883 ASTReader::ReadTemplateParameterList(ModuleFile &F,
7884 const RecordData &Record, unsigned &Idx) {
7885 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
7886 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
7887 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
7888
7889 unsigned NumParams = Record[Idx++];
7890 SmallVector<NamedDecl *, 16> Params;
7891 Params.reserve(NumParams);
7892 while (NumParams--)
7893 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
7894
7895 TemplateParameterList* TemplateParams =
7896 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
7897 Params, RAngleLoc);
7898 return TemplateParams;
7899 }
7900
7901 void
7902 ASTReader::
ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> & TemplArgs,ModuleFile & F,const RecordData & Record,unsigned & Idx,bool Canonicalize)7903 ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
7904 ModuleFile &F, const RecordData &Record,
7905 unsigned &Idx, bool Canonicalize) {
7906 unsigned NumTemplateArgs = Record[Idx++];
7907 TemplArgs.reserve(NumTemplateArgs);
7908 while (NumTemplateArgs--)
7909 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
7910 }
7911
7912 /// \brief Read a UnresolvedSet structure.
ReadUnresolvedSet(ModuleFile & F,LazyASTUnresolvedSet & Set,const RecordData & Record,unsigned & Idx)7913 void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
7914 const RecordData &Record, unsigned &Idx) {
7915 unsigned NumDecls = Record[Idx++];
7916 Set.reserve(Context, NumDecls);
7917 while (NumDecls--) {
7918 DeclID ID = ReadDeclID(F, Record, Idx);
7919 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
7920 Set.addLazyDecl(Context, ID, AS);
7921 }
7922 }
7923
7924 CXXBaseSpecifier
ReadCXXBaseSpecifier(ModuleFile & F,const RecordData & Record,unsigned & Idx)7925 ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
7926 const RecordData &Record, unsigned &Idx) {
7927 bool isVirtual = static_cast<bool>(Record[Idx++]);
7928 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
7929 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
7930 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
7931 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
7932 SourceRange Range = ReadSourceRange(F, Record, Idx);
7933 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
7934 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
7935 EllipsisLoc);
7936 Result.setInheritConstructors(inheritConstructors);
7937 return Result;
7938 }
7939
7940 CXXCtorInitializer **
ReadCXXCtorInitializers(ModuleFile & F,const RecordData & Record,unsigned & Idx)7941 ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
7942 unsigned &Idx) {
7943 unsigned NumInitializers = Record[Idx++];
7944 assert(NumInitializers && "wrote ctor initializers but have no inits");
7945 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
7946 for (unsigned i = 0; i != NumInitializers; ++i) {
7947 TypeSourceInfo *TInfo = nullptr;
7948 bool IsBaseVirtual = false;
7949 FieldDecl *Member = nullptr;
7950 IndirectFieldDecl *IndirectMember = nullptr;
7951
7952 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
7953 switch (Type) {
7954 case CTOR_INITIALIZER_BASE:
7955 TInfo = GetTypeSourceInfo(F, Record, Idx);
7956 IsBaseVirtual = Record[Idx++];
7957 break;
7958
7959 case CTOR_INITIALIZER_DELEGATING:
7960 TInfo = GetTypeSourceInfo(F, Record, Idx);
7961 break;
7962
7963 case CTOR_INITIALIZER_MEMBER:
7964 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
7965 break;
7966
7967 case CTOR_INITIALIZER_INDIRECT_MEMBER:
7968 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
7969 break;
7970 }
7971
7972 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
7973 Expr *Init = ReadExpr(F);
7974 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
7975 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
7976 bool IsWritten = Record[Idx++];
7977 unsigned SourceOrderOrNumArrayIndices;
7978 SmallVector<VarDecl *, 8> Indices;
7979 if (IsWritten) {
7980 SourceOrderOrNumArrayIndices = Record[Idx++];
7981 } else {
7982 SourceOrderOrNumArrayIndices = Record[Idx++];
7983 Indices.reserve(SourceOrderOrNumArrayIndices);
7984 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
7985 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
7986 }
7987
7988 CXXCtorInitializer *BOMInit;
7989 if (Type == CTOR_INITIALIZER_BASE) {
7990 BOMInit = new (Context)
7991 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
7992 RParenLoc, MemberOrEllipsisLoc);
7993 } else if (Type == CTOR_INITIALIZER_DELEGATING) {
7994 BOMInit = new (Context)
7995 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
7996 } else if (IsWritten) {
7997 if (Member)
7998 BOMInit = new (Context) CXXCtorInitializer(
7999 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc);
8000 else
8001 BOMInit = new (Context)
8002 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8003 LParenLoc, Init, RParenLoc);
8004 } else {
8005 if (IndirectMember) {
8006 assert(Indices.empty() && "Indirect field improperly initialized");
8007 BOMInit = new (Context)
8008 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8009 LParenLoc, Init, RParenLoc);
8010 } else {
8011 BOMInit = CXXCtorInitializer::Create(
8012 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc,
8013 Indices.data(), Indices.size());
8014 }
8015 }
8016
8017 if (IsWritten)
8018 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
8019 CtorInitializers[i] = BOMInit;
8020 }
8021
8022 return CtorInitializers;
8023 }
8024
8025 NestedNameSpecifier *
ReadNestedNameSpecifier(ModuleFile & F,const RecordData & Record,unsigned & Idx)8026 ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
8027 const RecordData &Record, unsigned &Idx) {
8028 unsigned N = Record[Idx++];
8029 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
8030 for (unsigned I = 0; I != N; ++I) {
8031 NestedNameSpecifier::SpecifierKind Kind
8032 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8033 switch (Kind) {
8034 case NestedNameSpecifier::Identifier: {
8035 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8036 NNS = NestedNameSpecifier::Create(Context, Prev, II);
8037 break;
8038 }
8039
8040 case NestedNameSpecifier::Namespace: {
8041 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8042 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8043 break;
8044 }
8045
8046 case NestedNameSpecifier::NamespaceAlias: {
8047 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8048 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8049 break;
8050 }
8051
8052 case NestedNameSpecifier::TypeSpec:
8053 case NestedNameSpecifier::TypeSpecWithTemplate: {
8054 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8055 if (!T)
8056 return nullptr;
8057
8058 bool Template = Record[Idx++];
8059 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8060 break;
8061 }
8062
8063 case NestedNameSpecifier::Global: {
8064 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8065 // No associated value, and there can't be a prefix.
8066 break;
8067 }
8068
8069 case NestedNameSpecifier::Super: {
8070 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8071 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8072 break;
8073 }
8074 }
8075 Prev = NNS;
8076 }
8077 return NNS;
8078 }
8079
8080 NestedNameSpecifierLoc
ReadNestedNameSpecifierLoc(ModuleFile & F,const RecordData & Record,unsigned & Idx)8081 ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
8082 unsigned &Idx) {
8083 unsigned N = Record[Idx++];
8084 NestedNameSpecifierLocBuilder Builder;
8085 for (unsigned I = 0; I != N; ++I) {
8086 NestedNameSpecifier::SpecifierKind Kind
8087 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8088 switch (Kind) {
8089 case NestedNameSpecifier::Identifier: {
8090 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8091 SourceRange Range = ReadSourceRange(F, Record, Idx);
8092 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8093 break;
8094 }
8095
8096 case NestedNameSpecifier::Namespace: {
8097 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8098 SourceRange Range = ReadSourceRange(F, Record, Idx);
8099 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8100 break;
8101 }
8102
8103 case NestedNameSpecifier::NamespaceAlias: {
8104 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8105 SourceRange Range = ReadSourceRange(F, Record, Idx);
8106 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8107 break;
8108 }
8109
8110 case NestedNameSpecifier::TypeSpec:
8111 case NestedNameSpecifier::TypeSpecWithTemplate: {
8112 bool Template = Record[Idx++];
8113 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
8114 if (!T)
8115 return NestedNameSpecifierLoc();
8116 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8117
8118 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8119 Builder.Extend(Context,
8120 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8121 T->getTypeLoc(), ColonColonLoc);
8122 break;
8123 }
8124
8125 case NestedNameSpecifier::Global: {
8126 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8127 Builder.MakeGlobal(Context, ColonColonLoc);
8128 break;
8129 }
8130
8131 case NestedNameSpecifier::Super: {
8132 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8133 SourceRange Range = ReadSourceRange(F, Record, Idx);
8134 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8135 break;
8136 }
8137 }
8138 }
8139
8140 return Builder.getWithLocInContext(Context);
8141 }
8142
8143 SourceRange
ReadSourceRange(ModuleFile & F,const RecordData & Record,unsigned & Idx)8144 ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8145 unsigned &Idx) {
8146 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8147 SourceLocation end = ReadSourceLocation(F, Record, Idx);
8148 return SourceRange(beg, end);
8149 }
8150
8151 /// \brief Read an integral value
ReadAPInt(const RecordData & Record,unsigned & Idx)8152 llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8153 unsigned BitWidth = Record[Idx++];
8154 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8155 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8156 Idx += NumWords;
8157 return Result;
8158 }
8159
8160 /// \brief Read a signed integral value
ReadAPSInt(const RecordData & Record,unsigned & Idx)8161 llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8162 bool isUnsigned = Record[Idx++];
8163 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8164 }
8165
8166 /// \brief Read a floating-point value
ReadAPFloat(const RecordData & Record,const llvm::fltSemantics & Sem,unsigned & Idx)8167 llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8168 const llvm::fltSemantics &Sem,
8169 unsigned &Idx) {
8170 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
8171 }
8172
8173 // \brief Read a string
ReadString(const RecordData & Record,unsigned & Idx)8174 std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8175 unsigned Len = Record[Idx++];
8176 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8177 Idx += Len;
8178 return Result;
8179 }
8180
ReadPath(ModuleFile & F,const RecordData & Record,unsigned & Idx)8181 std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
8182 unsigned &Idx) {
8183 std::string Filename = ReadString(Record, Idx);
8184 ResolveImportedPath(F, Filename);
8185 return Filename;
8186 }
8187
ReadVersionTuple(const RecordData & Record,unsigned & Idx)8188 VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
8189 unsigned &Idx) {
8190 unsigned Major = Record[Idx++];
8191 unsigned Minor = Record[Idx++];
8192 unsigned Subminor = Record[Idx++];
8193 if (Minor == 0)
8194 return VersionTuple(Major);
8195 if (Subminor == 0)
8196 return VersionTuple(Major, Minor - 1);
8197 return VersionTuple(Major, Minor - 1, Subminor - 1);
8198 }
8199
ReadCXXTemporary(ModuleFile & F,const RecordData & Record,unsigned & Idx)8200 CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
8201 const RecordData &Record,
8202 unsigned &Idx) {
8203 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8204 return CXXTemporary::Create(Context, Decl);
8205 }
8206
Diag(unsigned DiagID)8207 DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
8208 return Diag(CurrentImportLoc, DiagID);
8209 }
8210
Diag(SourceLocation Loc,unsigned DiagID)8211 DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
8212 return Diags.Report(Loc, DiagID);
8213 }
8214
8215 /// \brief Retrieve the identifier table associated with the
8216 /// preprocessor.
getIdentifierTable()8217 IdentifierTable &ASTReader::getIdentifierTable() {
8218 return PP.getIdentifierTable();
8219 }
8220
8221 /// \brief Record that the given ID maps to the given switch-case
8222 /// statement.
RecordSwitchCaseID(SwitchCase * SC,unsigned ID)8223 void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
8224 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
8225 "Already have a SwitchCase with this ID");
8226 (*CurrSwitchCaseStmts)[ID] = SC;
8227 }
8228
8229 /// \brief Retrieve the switch-case statement with the given ID.
getSwitchCaseWithID(unsigned ID)8230 SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
8231 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
8232 return (*CurrSwitchCaseStmts)[ID];
8233 }
8234
ClearSwitchCaseIDs()8235 void ASTReader::ClearSwitchCaseIDs() {
8236 CurrSwitchCaseStmts->clear();
8237 }
8238
ReadComments()8239 void ASTReader::ReadComments() {
8240 std::vector<RawComment *> Comments;
8241 for (SmallVectorImpl<std::pair<BitstreamCursor,
8242 serialization::ModuleFile *> >::iterator
8243 I = CommentsCursors.begin(),
8244 E = CommentsCursors.end();
8245 I != E; ++I) {
8246 Comments.clear();
8247 BitstreamCursor &Cursor = I->first;
8248 serialization::ModuleFile &F = *I->second;
8249 SavedStreamPosition SavedPosition(Cursor);
8250
8251 RecordData Record;
8252 while (true) {
8253 llvm::BitstreamEntry Entry =
8254 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
8255
8256 switch (Entry.Kind) {
8257 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8258 case llvm::BitstreamEntry::Error:
8259 Error("malformed block record in AST file");
8260 return;
8261 case llvm::BitstreamEntry::EndBlock:
8262 goto NextCursor;
8263 case llvm::BitstreamEntry::Record:
8264 // The interesting case.
8265 break;
8266 }
8267
8268 // Read a record.
8269 Record.clear();
8270 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
8271 case COMMENTS_RAW_COMMENT: {
8272 unsigned Idx = 0;
8273 SourceRange SR = ReadSourceRange(F, Record, Idx);
8274 RawComment::CommentKind Kind =
8275 (RawComment::CommentKind) Record[Idx++];
8276 bool IsTrailingComment = Record[Idx++];
8277 bool IsAlmostTrailingComment = Record[Idx++];
8278 Comments.push_back(new (Context) RawComment(
8279 SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8280 Context.getLangOpts().CommentOpts.ParseAllComments));
8281 break;
8282 }
8283 }
8284 }
8285 NextCursor:
8286 Context.Comments.addDeserializedComments(Comments);
8287 }
8288 }
8289
getOwningModuleNameForDiagnostic(const Decl * D)8290 std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
8291 // If we know the owning module, use it.
8292 if (Module *M = D->getImportedOwningModule())
8293 return M->getFullModuleName();
8294
8295 // Otherwise, use the name of the top-level module the decl is within.
8296 if (ModuleFile *M = getOwningModuleFile(D))
8297 return M->ModuleName;
8298
8299 // Not from a module.
8300 return "";
8301 }
8302
finishPendingActions()8303 void ASTReader::finishPendingActions() {
8304 while (!PendingIdentifierInfos.empty() ||
8305 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
8306 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
8307 !PendingUpdateRecords.empty()) {
8308 // If any identifiers with corresponding top-level declarations have
8309 // been loaded, load those declarations now.
8310 typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8311 TopLevelDeclsMap;
8312 TopLevelDeclsMap TopLevelDecls;
8313
8314 while (!PendingIdentifierInfos.empty()) {
8315 IdentifierInfo *II = PendingIdentifierInfos.back().first;
8316 SmallVector<uint32_t, 4> DeclIDs =
8317 std::move(PendingIdentifierInfos.back().second);
8318 PendingIdentifierInfos.pop_back();
8319
8320 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
8321 }
8322
8323 // For each decl chain that we wanted to complete while deserializing, mark
8324 // it as "still needs to be completed".
8325 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
8326 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
8327 }
8328 PendingIncompleteDeclChains.clear();
8329
8330 // Load pending declaration chains.
8331 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
8332 loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
8333 PendingDeclChains.clear();
8334
8335 // Make the most recent of the top-level declarations visible.
8336 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
8337 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
8338 IdentifierInfo *II = TLD->first;
8339 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
8340 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
8341 }
8342 }
8343
8344 // Load any pending macro definitions.
8345 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
8346 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
8347 SmallVector<PendingMacroInfo, 2> GlobalIDs;
8348 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
8349 // Initialize the macro history from chained-PCHs ahead of module imports.
8350 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8351 ++IDIdx) {
8352 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8353 if (Info.M->Kind != MK_ImplicitModule &&
8354 Info.M->Kind != MK_ExplicitModule)
8355 resolvePendingMacro(II, Info);
8356 }
8357 // Handle module imports.
8358 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
8359 ++IDIdx) {
8360 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
8361 if (Info.M->Kind == MK_ImplicitModule ||
8362 Info.M->Kind == MK_ExplicitModule)
8363 resolvePendingMacro(II, Info);
8364 }
8365 }
8366 PendingMacroIDs.clear();
8367
8368 // Wire up the DeclContexts for Decls that we delayed setting until
8369 // recursive loading is completed.
8370 while (!PendingDeclContextInfos.empty()) {
8371 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
8372 PendingDeclContextInfos.pop_front();
8373 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
8374 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
8375 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
8376 }
8377
8378 // Perform any pending declaration updates.
8379 while (!PendingUpdateRecords.empty()) {
8380 auto Update = PendingUpdateRecords.pop_back_val();
8381 ReadingKindTracker ReadingKind(Read_Decl, *this);
8382 loadDeclUpdateRecords(Update.first, Update.second);
8383 }
8384 }
8385
8386 // At this point, all update records for loaded decls are in place, so any
8387 // fake class definitions should have become real.
8388 assert(PendingFakeDefinitionData.empty() &&
8389 "faked up a class definition but never saw the real one");
8390
8391 // If we deserialized any C++ or Objective-C class definitions, any
8392 // Objective-C protocol definitions, or any redeclarable templates, make sure
8393 // that all redeclarations point to the definitions. Note that this can only
8394 // happen now, after the redeclaration chains have been fully wired.
8395 for (Decl *D : PendingDefinitions) {
8396 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
8397 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
8398 // Make sure that the TagType points at the definition.
8399 const_cast<TagType*>(TagT)->decl = TD;
8400 }
8401
8402 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
8403 for (auto *R = getMostRecentExistingDecl(RD); R;
8404 R = R->getPreviousDecl()) {
8405 assert((R == D) ==
8406 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
8407 "declaration thinks it's the definition but it isn't");
8408 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
8409 }
8410 }
8411
8412 continue;
8413 }
8414
8415 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
8416 // Make sure that the ObjCInterfaceType points at the definition.
8417 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
8418 ->Decl = ID;
8419
8420 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
8421 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
8422
8423 continue;
8424 }
8425
8426 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
8427 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
8428 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
8429
8430 continue;
8431 }
8432
8433 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
8434 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
8435 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
8436 }
8437 PendingDefinitions.clear();
8438
8439 // Load the bodies of any functions or methods we've encountered. We do
8440 // this now (delayed) so that we can be sure that the declaration chains
8441 // have been fully wired up (hasBody relies on this).
8442 // FIXME: We shouldn't require complete redeclaration chains here.
8443 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
8444 PBEnd = PendingBodies.end();
8445 PB != PBEnd; ++PB) {
8446 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
8447 // FIXME: Check for =delete/=default?
8448 // FIXME: Complain about ODR violations here?
8449 if (!getContext().getLangOpts().Modules || !FD->hasBody())
8450 FD->setLazyBody(PB->second);
8451 continue;
8452 }
8453
8454 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
8455 if (!getContext().getLangOpts().Modules || !MD->hasBody())
8456 MD->setLazyBody(PB->second);
8457 }
8458 PendingBodies.clear();
8459
8460 // Do some cleanup.
8461 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
8462 getContext().deduplicateMergedDefinitonsFor(ND);
8463 PendingMergedDefinitionsToDeduplicate.clear();
8464 }
8465
diagnoseOdrViolations()8466 void ASTReader::diagnoseOdrViolations() {
8467 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
8468 return;
8469
8470 // Trigger the import of the full definition of each class that had any
8471 // odr-merging problems, so we can produce better diagnostics for them.
8472 // These updates may in turn find and diagnose some ODR failures, so take
8473 // ownership of the set first.
8474 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
8475 PendingOdrMergeFailures.clear();
8476 for (auto &Merge : OdrMergeFailures) {
8477 Merge.first->buildLookup();
8478 Merge.first->decls_begin();
8479 Merge.first->bases_begin();
8480 Merge.first->vbases_begin();
8481 for (auto *RD : Merge.second) {
8482 RD->decls_begin();
8483 RD->bases_begin();
8484 RD->vbases_begin();
8485 }
8486 }
8487
8488 // For each declaration from a merged context, check that the canonical
8489 // definition of that context also contains a declaration of the same
8490 // entity.
8491 //
8492 // Caution: this loop does things that might invalidate iterators into
8493 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
8494 while (!PendingOdrMergeChecks.empty()) {
8495 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
8496
8497 // FIXME: Skip over implicit declarations for now. This matters for things
8498 // like implicitly-declared special member functions. This isn't entirely
8499 // correct; we can end up with multiple unmerged declarations of the same
8500 // implicit entity.
8501 if (D->isImplicit())
8502 continue;
8503
8504 DeclContext *CanonDef = D->getDeclContext();
8505
8506 bool Found = false;
8507 const Decl *DCanon = D->getCanonicalDecl();
8508
8509 for (auto RI : D->redecls()) {
8510 if (RI->getLexicalDeclContext() == CanonDef) {
8511 Found = true;
8512 break;
8513 }
8514 }
8515 if (Found)
8516 continue;
8517
8518 // Quick check failed, time to do the slow thing. Note, we can't just
8519 // look up the name of D in CanonDef here, because the member that is
8520 // in CanonDef might not be found by name lookup (it might have been
8521 // replaced by a more recent declaration in the lookup table), and we
8522 // can't necessarily find it in the redeclaration chain because it might
8523 // be merely mergeable, not redeclarable.
8524 llvm::SmallVector<const NamedDecl*, 4> Candidates;
8525 for (auto *CanonMember : CanonDef->decls()) {
8526 if (CanonMember->getCanonicalDecl() == DCanon) {
8527 // This can happen if the declaration is merely mergeable and not
8528 // actually redeclarable (we looked for redeclarations earlier).
8529 //
8530 // FIXME: We should be able to detect this more efficiently, without
8531 // pulling in all of the members of CanonDef.
8532 Found = true;
8533 break;
8534 }
8535 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
8536 if (ND->getDeclName() == D->getDeclName())
8537 Candidates.push_back(ND);
8538 }
8539
8540 if (!Found) {
8541 // The AST doesn't like TagDecls becoming invalid after they've been
8542 // completed. We only really need to mark FieldDecls as invalid here.
8543 if (!isa<TagDecl>(D))
8544 D->setInvalidDecl();
8545
8546 // Ensure we don't accidentally recursively enter deserialization while
8547 // we're producing our diagnostic.
8548 Deserializing RecursionGuard(this);
8549
8550 std::string CanonDefModule =
8551 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
8552 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
8553 << D << getOwningModuleNameForDiagnostic(D)
8554 << CanonDef << CanonDefModule.empty() << CanonDefModule;
8555
8556 if (Candidates.empty())
8557 Diag(cast<Decl>(CanonDef)->getLocation(),
8558 diag::note_module_odr_violation_no_possible_decls) << D;
8559 else {
8560 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
8561 Diag(Candidates[I]->getLocation(),
8562 diag::note_module_odr_violation_possible_decl)
8563 << Candidates[I];
8564 }
8565
8566 DiagnosedOdrMergeFailures.insert(CanonDef);
8567 }
8568 }
8569
8570 if (OdrMergeFailures.empty())
8571 return;
8572
8573 // Ensure we don't accidentally recursively enter deserialization while
8574 // we're producing our diagnostics.
8575 Deserializing RecursionGuard(this);
8576
8577 // Issue any pending ODR-failure diagnostics.
8578 for (auto &Merge : OdrMergeFailures) {
8579 // If we've already pointed out a specific problem with this class, don't
8580 // bother issuing a general "something's different" diagnostic.
8581 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
8582 continue;
8583
8584 bool Diagnosed = false;
8585 for (auto *RD : Merge.second) {
8586 // Multiple different declarations got merged together; tell the user
8587 // where they came from.
8588 if (Merge.first != RD) {
8589 // FIXME: Walk the definition, figure out what's different,
8590 // and diagnose that.
8591 if (!Diagnosed) {
8592 std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
8593 Diag(Merge.first->getLocation(),
8594 diag::err_module_odr_violation_different_definitions)
8595 << Merge.first << Module.empty() << Module;
8596 Diagnosed = true;
8597 }
8598
8599 Diag(RD->getLocation(),
8600 diag::note_module_odr_violation_different_definitions)
8601 << getOwningModuleNameForDiagnostic(RD);
8602 }
8603 }
8604
8605 if (!Diagnosed) {
8606 // All definitions are updates to the same declaration. This happens if a
8607 // module instantiates the declaration of a class template specialization
8608 // and two or more other modules instantiate its definition.
8609 //
8610 // FIXME: Indicate which modules had instantiations of this definition.
8611 // FIXME: How can this even happen?
8612 Diag(Merge.first->getLocation(),
8613 diag::err_module_odr_violation_different_instantiations)
8614 << Merge.first;
8615 }
8616 }
8617 }
8618
StartedDeserializing()8619 void ASTReader::StartedDeserializing() {
8620 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
8621 ReadTimer->startTimer();
8622 }
8623
FinishedDeserializing()8624 void ASTReader::FinishedDeserializing() {
8625 assert(NumCurrentElementsDeserializing &&
8626 "FinishedDeserializing not paired with StartedDeserializing");
8627 if (NumCurrentElementsDeserializing == 1) {
8628 // We decrease NumCurrentElementsDeserializing only after pending actions
8629 // are finished, to avoid recursively re-calling finishPendingActions().
8630 finishPendingActions();
8631 }
8632 --NumCurrentElementsDeserializing;
8633
8634 if (NumCurrentElementsDeserializing == 0) {
8635 // Propagate exception specification updates along redeclaration chains.
8636 while (!PendingExceptionSpecUpdates.empty()) {
8637 auto Updates = std::move(PendingExceptionSpecUpdates);
8638 PendingExceptionSpecUpdates.clear();
8639 for (auto Update : Updates) {
8640 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
8641 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
8642 if (auto *Listener = Context.getASTMutationListener())
8643 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
8644 for (auto *Redecl : Update.second->redecls())
8645 Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
8646 }
8647 }
8648
8649 if (ReadTimer)
8650 ReadTimer->stopTimer();
8651
8652 diagnoseOdrViolations();
8653
8654 // We are not in recursive loading, so it's safe to pass the "interesting"
8655 // decls to the consumer.
8656 if (Consumer)
8657 PassInterestingDeclsToConsumer();
8658 }
8659 }
8660
pushExternalDeclIntoScope(NamedDecl * D,DeclarationName Name)8661 void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
8662 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
8663 // Remove any fake results before adding any real ones.
8664 auto It = PendingFakeLookupResults.find(II);
8665 if (It != PendingFakeLookupResults.end()) {
8666 for (auto *ND : It->second)
8667 SemaObj->IdResolver.RemoveDecl(ND);
8668 // FIXME: this works around module+PCH performance issue.
8669 // Rather than erase the result from the map, which is O(n), just clear
8670 // the vector of NamedDecls.
8671 It->second.clear();
8672 }
8673 }
8674
8675 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
8676 SemaObj->TUScope->AddDecl(D);
8677 } else if (SemaObj->TUScope) {
8678 // Adding the decl to IdResolver may have failed because it was already in
8679 // (even though it was not added in scope). If it is already in, make sure
8680 // it gets in the scope as well.
8681 if (std::find(SemaObj->IdResolver.begin(Name),
8682 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
8683 SemaObj->TUScope->AddDecl(D);
8684 }
8685 }
8686
ASTReader(Preprocessor & PP,ASTContext & Context,const PCHContainerReader & PCHContainerRdr,ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,StringRef isysroot,bool DisableValidation,bool AllowASTWithCompilerErrors,bool AllowConfigurationMismatch,bool ValidateSystemInputs,bool UseGlobalIndex,std::unique_ptr<llvm::Timer> ReadTimer)8687 ASTReader::ASTReader(
8688 Preprocessor &PP, ASTContext &Context,
8689 const PCHContainerReader &PCHContainerRdr,
8690 ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,
8691 StringRef isysroot, bool DisableValidation,
8692 bool AllowASTWithCompilerErrors,
8693 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
8694 bool UseGlobalIndex,
8695 std::unique_ptr<llvm::Timer> ReadTimer)
8696 : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr),
8697 OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
8698 FileMgr(PP.getFileManager()), PCHContainerRdr(PCHContainerRdr),
8699 Diags(PP.getDiagnostics()), SemaObj(nullptr), PP(PP), Context(Context),
8700 Consumer(nullptr), ModuleMgr(PP.getFileManager(), PCHContainerRdr),
8701 DummyIdResolver(PP),
8702 ReadTimer(std::move(ReadTimer)),
8703 PragmaMSStructState(-1),
8704 PragmaMSPointersToMembersState(-1),
8705 isysroot(isysroot), DisableValidation(DisableValidation),
8706 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
8707 AllowConfigurationMismatch(AllowConfigurationMismatch),
8708 ValidateSystemInputs(ValidateSystemInputs),
8709 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
8710 CurrSwitchCaseStmts(&SwitchCaseStmts), NumSLocEntriesRead(0),
8711 TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0),
8712 NumMacrosRead(0), TotalNumMacros(0), NumIdentifierLookups(0),
8713 NumIdentifierLookupHits(0), NumSelectorsRead(0),
8714 NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
8715 NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
8716 NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
8717 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
8718 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
8719 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
8720 PassingDeclsToConsumer(false), ReadingKind(Read_None) {
8721 SourceMgr.setExternalSLocEntrySource(this);
8722
8723 for (const auto &Ext : Extensions) {
8724 auto BlockName = Ext->getExtensionMetadata().BlockName;
8725 auto Known = ModuleFileExtensions.find(BlockName);
8726 if (Known != ModuleFileExtensions.end()) {
8727 Diags.Report(diag::warn_duplicate_module_file_extension)
8728 << BlockName;
8729 continue;
8730 }
8731
8732 ModuleFileExtensions.insert({BlockName, Ext});
8733 }
8734 }
8735
~ASTReader()8736 ASTReader::~ASTReader() {
8737 if (OwnsDeserializationListener)
8738 delete DeserializationListener;
8739 }
8740
getIdResolver()8741 IdentifierResolver &ASTReader::getIdResolver() {
8742 return SemaObj ? SemaObj->IdResolver : DummyIdResolver;
8743 }
8744