blob: 9b118d56f1024b569432f33948c8b7bdc39e03ef [file] [log] [blame]
Richard Smith9e2341d2015-03-23 03:25:59 +00001//===-- ASTReader.cpp - AST File Reader ----------------------------------===//
Guy Benyei11169dd2012-12-18 14:30:41 +00002//
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"
Adrian Prantlbb165fb2015-06-20 18:53:08 +000022#include "clang/Frontend/PCHContainerOperations.h"
Richard Smithd88a7f12015-09-01 20:35:42 +000023#include "clang/AST/ASTMutationListener.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000024#include "clang/AST/NestedNameSpecifier.h"
25#include "clang/AST/Type.h"
26#include "clang/AST/TypeLocVisitor.h"
Benjamin Kramerf3ca26982014-05-10 16:31:55 +000027#include "clang/Basic/DiagnosticOptions.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000028#include "clang/Basic/FileManager.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000029#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"
Ben Langmuirb92de022014-04-29 16:25:26 +000035#include "clang/Frontend/Utils.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000036#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"
Douglas Gregore060e572013-01-25 01:03:03 +000045#include "clang/Serialization/GlobalModuleIndex.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000046#include "clang/Serialization/ModuleManager.h"
47#include "clang/Serialization/SerializationDiagnostic.h"
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +000048#include "llvm/ADT/Hashing.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000049#include "llvm/ADT/StringExtras.h"
50#include "llvm/Bitcode/BitstreamReader.h"
Richard Smithaada85c2016-02-06 02:06:43 +000051#include "llvm/Support/Compression.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000052#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"
Dmitri Gribenkof430da42014-02-12 10:33:14 +000057#include "llvm/Support/raw_ostream.h"
Guy Benyei11169dd2012-12-18 14:30:41 +000058#include <algorithm>
Chris Lattner91f373e2013-01-20 00:57:52 +000059#include <cstdio>
Guy Benyei11169dd2012-12-18 14:30:41 +000060#include <iterator>
Rafael Espindola8a8e5542014-06-12 17:19:42 +000061#include <system_error>
Guy Benyei11169dd2012-12-18 14:30:41 +000062
63using namespace clang;
64using namespace clang::serialization;
65using namespace clang::serialization::reader;
Chris Lattner7fb3bef2013-01-20 00:56:42 +000066using llvm::BitstreamCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +000067
Ben Langmuircb69b572014-03-07 06:40:32 +000068
69//===----------------------------------------------------------------------===//
70// ChainedASTReaderListener implementation
71//===----------------------------------------------------------------------===//
72
73bool
74ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
75 return First->ReadFullVersionInformation(FullVersion) ||
76 Second->ReadFullVersionInformation(FullVersion);
77}
Ben Langmuir4f5212a2014-04-14 22:12:44 +000078void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
79 First->ReadModuleName(ModuleName);
80 Second->ReadModuleName(ModuleName);
81}
82void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
83 First->ReadModuleMapFile(ModuleMapPath);
84 Second->ReadModuleMapFile(ModuleMapPath);
85}
Richard Smith1e2cf0d2014-10-31 02:28:58 +000086bool
87ChainedASTReaderListener::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);
Ben Langmuircb69b572014-03-07 06:40:32 +000094}
Chandler Carruth0d745bc2015-03-14 04:47:43 +000095bool 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);
Ben Langmuircb69b572014-03-07 06:40:32 +0000102}
103bool ChainedASTReaderListener::ReadDiagnosticOptions(
Ben Langmuirb92de022014-04-29 16:25:26 +0000104 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
Ben Langmuircb69b572014-03-07 06:40:32 +0000105 return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
106 Second->ReadDiagnosticOptions(DiagOpts, Complain);
107}
108bool
109ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
110 bool Complain) {
111 return First->ReadFileSystemOptions(FSOpts, Complain) ||
112 Second->ReadFileSystemOptions(FSOpts, Complain);
113}
114
115bool ChainedASTReaderListener::ReadHeaderSearchOptions(
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000116 const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
117 bool Complain) {
118 return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
119 Complain) ||
120 Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
121 Complain);
Ben Langmuircb69b572014-03-07 06:40:32 +0000122}
123bool 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}
130void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
131 unsigned Value) {
132 First->ReadCounter(M, Value);
133 Second->ReadCounter(M, Value);
134}
135bool ChainedASTReaderListener::needsInputFileVisitation() {
136 return First->needsInputFileVisitation() ||
137 Second->needsInputFileVisitation();
138}
139bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
140 return First->needsSystemInputFileVisitation() ||
141 Second->needsSystemInputFileVisitation();
142}
Richard Smith216a3bd2015-08-13 17:57:10 +0000143void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
144 ModuleKind Kind) {
145 First->visitModuleFile(Filename, Kind);
146 Second->visitModuleFile(Filename, Kind);
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000147}
Ben Langmuircb69b572014-03-07 06:40:32 +0000148bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
Argyrios Kyrtzidis68ccbe02014-03-14 02:26:31 +0000149 bool isSystem,
Richard Smith216a3bd2015-08-13 17:57:10 +0000150 bool isOverridden,
151 bool isExplicitModule) {
Justin Bognerc65a66d2014-05-22 06:04:59 +0000152 bool Continue = false;
153 if (First->needsInputFileVisitation() &&
154 (!isSystem || First->needsSystemInputFileVisitation()))
Richard Smith216a3bd2015-08-13 17:57:10 +0000155 Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
156 isExplicitModule);
Justin Bognerc65a66d2014-05-22 06:04:59 +0000157 if (Second->needsInputFileVisitation() &&
158 (!isSystem || Second->needsSystemInputFileVisitation()))
Richard Smith216a3bd2015-08-13 17:57:10 +0000159 Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
160 isExplicitModule);
Justin Bognerc65a66d2014-05-22 06:04:59 +0000161 return Continue;
Ben Langmuircb69b572014-03-07 06:40:32 +0000162}
163
Douglas Gregor6623e1f2015-11-03 18:33:07 +0000164void ChainedASTReaderListener::readModuleFileExtension(
165 const ModuleFileExtensionMetadata &Metadata) {
166 First->readModuleFileExtension(Metadata);
167 Second->readModuleFileExtension(Metadata);
168}
169
Guy Benyei11169dd2012-12-18 14:30:41 +0000170//===----------------------------------------------------------------------===//
171// PCH validator implementation
172//===----------------------------------------------------------------------===//
173
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +0000174ASTReaderListener::~ASTReaderListener() {}
Guy Benyei11169dd2012-12-18 14:30:41 +0000175
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.
Richard Smith1e2cf0d2014-10-31 02:28:58 +0000180/// \param AllowCompatibleDifferences If true, differences between compatible
181/// language options will be permitted.
Guy Benyei11169dd2012-12-18 14:30:41 +0000182///
183/// \returns true if the languagae options mis-match, false otherwise.
184static bool checkLanguageOptions(const LangOptions &LangOpts,
185 const LangOptions &ExistingLangOpts,
Richard Smith1e2cf0d2014-10-31 02:28:58 +0000186 DiagnosticsEngine *Diags,
187 bool AllowCompatibleDifferences = true) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000188#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
Richard Smith1e2cf0d2014-10-31 02:28:58 +0000212#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
Guy Benyei11169dd2012-12-18 14:30:41 +0000220#define BENIGN_LANGOPT(Name, Bits, Default, Description)
221#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
222#include "clang/Basic/LangOptions.def"
223
Ben Langmuircd98cb72015-06-23 18:20:18 +0000224 if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
225 if (Diags)
226 Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
227 return true;
228 }
229
Guy Benyei11169dd2012-12-18 14:30:41 +0000230 if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
231 if (Diags)
232 Diags->Report(diag::err_pch_langopt_value_mismatch)
233 << "target Objective-C runtime";
234 return true;
235 }
236
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +0000237 if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
238 LangOpts.CommentOpts.BlockCommandNames) {
239 if (Diags)
240 Diags->Report(diag::err_pch_langopt_value_mismatch)
241 << "block command names";
242 return true;
243 }
244
Guy Benyei11169dd2012-12-18 14:30:41 +0000245 return false;
246}
247
248/// \brief Compare the given set of target options against an existing set of
249/// target options.
250///
251/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
252///
253/// \returns true if the target options mis-match, false otherwise.
254static bool checkTargetOptions(const TargetOptions &TargetOpts,
255 const TargetOptions &ExistingTargetOpts,
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000256 DiagnosticsEngine *Diags,
257 bool AllowCompatibleDifferences = true) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000258#define CHECK_TARGET_OPT(Field, Name) \
259 if (TargetOpts.Field != ExistingTargetOpts.Field) { \
260 if (Diags) \
261 Diags->Report(diag::err_pch_targetopt_mismatch) \
262 << Name << TargetOpts.Field << ExistingTargetOpts.Field; \
263 return true; \
264 }
265
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000266 // The triple and ABI must match exactly.
Guy Benyei11169dd2012-12-18 14:30:41 +0000267 CHECK_TARGET_OPT(Triple, "target");
Guy Benyei11169dd2012-12-18 14:30:41 +0000268 CHECK_TARGET_OPT(ABI, "target ABI");
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000269
270 // We can tolerate different CPUs in many cases, notably when one CPU
271 // supports a strict superset of another. When allowing compatible
272 // differences skip this check.
273 if (!AllowCompatibleDifferences)
274 CHECK_TARGET_OPT(CPU, "target CPU");
275
Guy Benyei11169dd2012-12-18 14:30:41 +0000276#undef CHECK_TARGET_OPT
277
278 // Compare feature sets.
279 SmallVector<StringRef, 4> ExistingFeatures(
280 ExistingTargetOpts.FeaturesAsWritten.begin(),
281 ExistingTargetOpts.FeaturesAsWritten.end());
282 SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
283 TargetOpts.FeaturesAsWritten.end());
284 std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
285 std::sort(ReadFeatures.begin(), ReadFeatures.end());
286
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000287 // We compute the set difference in both directions explicitly so that we can
288 // diagnose the differences differently.
289 SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
290 std::set_difference(
291 ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
292 ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
293 std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
294 ExistingFeatures.begin(), ExistingFeatures.end(),
295 std::back_inserter(UnmatchedReadFeatures));
Guy Benyei11169dd2012-12-18 14:30:41 +0000296
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000297 // If we are allowing compatible differences and the read feature set is
298 // a strict subset of the existing feature set, there is nothing to diagnose.
299 if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
300 return false;
Guy Benyei11169dd2012-12-18 14:30:41 +0000301
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000302 if (Diags) {
303 for (StringRef Feature : UnmatchedReadFeatures)
Guy Benyei11169dd2012-12-18 14:30:41 +0000304 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000305 << /* is-existing-feature */ false << Feature;
306 for (StringRef Feature : UnmatchedExistingFeatures)
307 Diags->Report(diag::err_pch_targetopt_feature_mismatch)
308 << /* is-existing-feature */ true << Feature;
Guy Benyei11169dd2012-12-18 14:30:41 +0000309 }
310
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000311 return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
Guy Benyei11169dd2012-12-18 14:30:41 +0000312}
313
314bool
315PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
Richard Smith1e2cf0d2014-10-31 02:28:58 +0000316 bool Complain,
317 bool AllowCompatibleDifferences) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000318 const LangOptions &ExistingLangOpts = PP.getLangOpts();
319 return checkLanguageOptions(LangOpts, ExistingLangOpts,
Richard Smith1e2cf0d2014-10-31 02:28:58 +0000320 Complain ? &Reader.Diags : nullptr,
321 AllowCompatibleDifferences);
Guy Benyei11169dd2012-12-18 14:30:41 +0000322}
323
324bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000325 bool Complain,
326 bool AllowCompatibleDifferences) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000327 const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
328 return checkTargetOptions(TargetOpts, ExistingTargetOpts,
Chandler Carruth0d745bc2015-03-14 04:47:43 +0000329 Complain ? &Reader.Diags : nullptr,
330 AllowCompatibleDifferences);
Guy Benyei11169dd2012-12-18 14:30:41 +0000331}
332
333namespace {
334 typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
335 MacroDefinitionsMap;
Craig Topper3598eb72013-07-05 04:43:31 +0000336 typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
337 DeclsMap;
Guy Benyei11169dd2012-12-18 14:30:41 +0000338}
339
Ben Langmuirb92de022014-04-29 16:25:26 +0000340static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
341 DiagnosticsEngine &Diags,
342 bool Complain) {
343 typedef DiagnosticsEngine::Level Level;
344
345 // Check current mappings for new -Werror mappings, and the stored mappings
346 // for cases that were explicitly mapped to *not* be errors that are now
347 // errors because of options like -Werror.
348 DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
349
350 for (DiagnosticsEngine *MappingSource : MappingSources) {
351 for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
352 diag::kind DiagID = DiagIDMappingPair.first;
353 Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
354 if (CurLevel < DiagnosticsEngine::Error)
355 continue; // not significant
356 Level StoredLevel =
357 StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
358 if (StoredLevel < DiagnosticsEngine::Error) {
359 if (Complain)
360 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
361 Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
362 return true;
363 }
364 }
365 }
366
367 return false;
368}
369
Alp Tokerac4e8e52014-06-22 21:58:33 +0000370static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
371 diag::Severity Ext = Diags.getExtensionHandlingBehavior();
372 if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
373 return true;
374 return Ext >= diag::Severity::Error;
Ben Langmuirb92de022014-04-29 16:25:26 +0000375}
376
377static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
378 DiagnosticsEngine &Diags,
379 bool IsSystem, bool Complain) {
380 // Top-level options
381 if (IsSystem) {
382 if (Diags.getSuppressSystemWarnings())
383 return false;
384 // If -Wsystem-headers was not enabled before, be conservative
385 if (StoredDiags.getSuppressSystemWarnings()) {
386 if (Complain)
387 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
388 return true;
389 }
390 }
391
392 if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
393 if (Complain)
394 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
395 return true;
396 }
397
398 if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
399 !StoredDiags.getEnableAllWarnings()) {
400 if (Complain)
401 Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
402 return true;
403 }
404
405 if (isExtHandlingFromDiagsError(Diags) &&
406 !isExtHandlingFromDiagsError(StoredDiags)) {
407 if (Complain)
408 Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
409 return true;
410 }
411
412 return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
413}
414
415bool PCHValidator::ReadDiagnosticOptions(
416 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
417 DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
418 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
419 IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
Alp Tokerf994cef2014-07-05 03:08:06 +0000420 new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
Ben Langmuirb92de022014-04-29 16:25:26 +0000421 // This should never fail, because we would have processed these options
422 // before writing them to an ASTFile.
423 ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
424
425 ModuleManager &ModuleMgr = Reader.getModuleManager();
426 assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
427
428 // If the original import came from a file explicitly generated by the user,
429 // don't check the diagnostic mappings.
430 // FIXME: currently this is approximated by checking whether this is not a
Richard Smithe842a472014-10-22 02:05:46 +0000431 // module import of an implicitly-loaded module file.
Ben Langmuirb92de022014-04-29 16:25:26 +0000432 // Note: ModuleMgr.rbegin() may not be the current module, but it must be in
433 // the transitive closure of its imports, since unrelated modules cannot be
434 // imported until after this module finishes validation.
435 ModuleFile *TopImport = *ModuleMgr.rbegin();
436 while (!TopImport->ImportedBy.empty())
437 TopImport = TopImport->ImportedBy[0];
Richard Smithe842a472014-10-22 02:05:46 +0000438 if (TopImport->Kind != MK_ImplicitModule)
Ben Langmuirb92de022014-04-29 16:25:26 +0000439 return false;
440
441 StringRef ModuleName = TopImport->ModuleName;
442 assert(!ModuleName.empty() && "diagnostic options read before module name");
443
444 Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
445 assert(M && "missing module");
446
447 // FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
448 // contains the union of their flags.
449 return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain);
450}
451
Guy Benyei11169dd2012-12-18 14:30:41 +0000452/// \brief Collect the macro definitions provided by the given preprocessor
453/// options.
Craig Toppera13603a2014-05-22 05:54:18 +0000454static void
455collectMacroDefinitions(const PreprocessorOptions &PPOpts,
456 MacroDefinitionsMap &Macros,
457 SmallVectorImpl<StringRef> *MacroNames = nullptr) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000458 for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
459 StringRef Macro = PPOpts.Macros[I].first;
460 bool IsUndef = PPOpts.Macros[I].second;
461
462 std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
463 StringRef MacroName = MacroPair.first;
464 StringRef MacroBody = MacroPair.second;
465
466 // For an #undef'd macro, we only care about the name.
467 if (IsUndef) {
468 if (MacroNames && !Macros.count(MacroName))
469 MacroNames->push_back(MacroName);
470
471 Macros[MacroName] = std::make_pair("", true);
472 continue;
473 }
474
475 // For a #define'd macro, figure out the actual definition.
476 if (MacroName.size() == Macro.size())
477 MacroBody = "1";
478 else {
479 // Note: GCC drops anything following an end-of-line character.
480 StringRef::size_type End = MacroBody.find_first_of("\n\r");
481 MacroBody = MacroBody.substr(0, End);
482 }
483
484 if (MacroNames && !Macros.count(MacroName))
485 MacroNames->push_back(MacroName);
486 Macros[MacroName] = std::make_pair(MacroBody, false);
487 }
488}
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000489
Guy Benyei11169dd2012-12-18 14:30:41 +0000490/// \brief Check the preprocessor options deserialized from the control block
491/// against the preprocessor options in an existing preprocessor.
492///
493/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
494static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
495 const PreprocessorOptions &ExistingPPOpts,
496 DiagnosticsEngine *Diags,
497 FileManager &FileMgr,
Argyrios Kyrtzidisd3afa0c2013-04-26 21:33:40 +0000498 std::string &SuggestedPredefines,
499 const LangOptions &LangOpts) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000500 // Check macro definitions.
501 MacroDefinitionsMap ASTFileMacros;
502 collectMacroDefinitions(PPOpts, ASTFileMacros);
503 MacroDefinitionsMap ExistingMacros;
504 SmallVector<StringRef, 4> ExistingMacroNames;
505 collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
506
507 for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
508 // Dig out the macro definition in the existing preprocessor options.
509 StringRef MacroName = ExistingMacroNames[I];
510 std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
511
512 // Check whether we know anything about this macro name or not.
513 llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
514 = ASTFileMacros.find(MacroName);
515 if (Known == ASTFileMacros.end()) {
516 // FIXME: Check whether this identifier was referenced anywhere in the
517 // AST file. If so, we should reject the AST file. Unfortunately, this
518 // information isn't in the control block. What shall we do about it?
519
520 if (Existing.second) {
521 SuggestedPredefines += "#undef ";
522 SuggestedPredefines += MacroName.str();
523 SuggestedPredefines += '\n';
524 } else {
525 SuggestedPredefines += "#define ";
526 SuggestedPredefines += MacroName.str();
527 SuggestedPredefines += ' ';
528 SuggestedPredefines += Existing.first.str();
529 SuggestedPredefines += '\n';
530 }
531 continue;
532 }
533
534 // If the macro was defined in one but undef'd in the other, we have a
535 // conflict.
536 if (Existing.second != Known->second.second) {
537 if (Diags) {
538 Diags->Report(diag::err_pch_macro_def_undef)
539 << MacroName << Known->second.second;
540 }
541 return true;
542 }
543
544 // If the macro was #undef'd in both, or if the macro bodies are identical,
545 // it's fine.
546 if (Existing.second || Existing.first == Known->second.first)
547 continue;
548
549 // The macro bodies differ; complain.
550 if (Diags) {
551 Diags->Report(diag::err_pch_macro_def_conflict)
552 << MacroName << Known->second.first << Existing.first;
553 }
554 return true;
555 }
556
557 // Check whether we're using predefines.
558 if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) {
559 if (Diags) {
560 Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
561 }
562 return true;
563 }
564
Argyrios Kyrtzidisd3afa0c2013-04-26 21:33:40 +0000565 // Detailed record is important since it is used for the module cache hash.
566 if (LangOpts.Modules &&
567 PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) {
568 if (Diags) {
569 Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
570 }
571 return true;
572 }
573
Guy Benyei11169dd2012-12-18 14:30:41 +0000574 // Compute the #include and #include_macros lines we need.
575 for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
576 StringRef File = ExistingPPOpts.Includes[I];
577 if (File == ExistingPPOpts.ImplicitPCHInclude)
578 continue;
579
580 if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
581 != PPOpts.Includes.end())
582 continue;
583
584 SuggestedPredefines += "#include \"";
Manuel Klimek9af34ae2014-08-12 08:25:57 +0000585 SuggestedPredefines += File;
Guy Benyei11169dd2012-12-18 14:30:41 +0000586 SuggestedPredefines += "\"\n";
587 }
588
589 for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
590 StringRef File = ExistingPPOpts.MacroIncludes[I];
591 if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
592 File)
593 != PPOpts.MacroIncludes.end())
594 continue;
595
596 SuggestedPredefines += "#__include_macros \"";
Manuel Klimek9af34ae2014-08-12 08:25:57 +0000597 SuggestedPredefines += File;
Guy Benyei11169dd2012-12-18 14:30:41 +0000598 SuggestedPredefines += "\"\n##\n";
599 }
600
601 return false;
602}
603
604bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
605 bool Complain,
606 std::string &SuggestedPredefines) {
607 const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
608
609 return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
Craig Toppera13603a2014-05-22 05:54:18 +0000610 Complain? &Reader.Diags : nullptr,
Guy Benyei11169dd2012-12-18 14:30:41 +0000611 PP.getFileManager(),
Argyrios Kyrtzidisd3afa0c2013-04-26 21:33:40 +0000612 SuggestedPredefines,
613 PP.getLangOpts());
Guy Benyei11169dd2012-12-18 14:30:41 +0000614}
615
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +0000616/// Check the header search options deserialized from the control block
617/// against the header search options in an existing preprocessor.
618///
619/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
620static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
621 StringRef SpecificModuleCachePath,
622 StringRef ExistingModuleCachePath,
623 DiagnosticsEngine *Diags,
624 const LangOptions &LangOpts) {
625 if (LangOpts.Modules) {
626 if (SpecificModuleCachePath != ExistingModuleCachePath) {
627 if (Diags)
628 Diags->Report(diag::err_pch_modulecache_mismatch)
629 << SpecificModuleCachePath << ExistingModuleCachePath;
630 return true;
631 }
632 }
633
634 return false;
635}
636
637bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
638 StringRef SpecificModuleCachePath,
639 bool Complain) {
640 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
641 PP.getHeaderSearchInfo().getModuleCachePath(),
642 Complain ? &Reader.Diags : nullptr,
643 PP.getLangOpts());
644}
645
Guy Benyei11169dd2012-12-18 14:30:41 +0000646void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
647 PP.setCounterValue(Value);
648}
649
650//===----------------------------------------------------------------------===//
651// AST reader implementation
652//===----------------------------------------------------------------------===//
653
Nico Weber824285e2014-05-08 04:26:47 +0000654void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
655 bool TakeOwnership) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000656 DeserializationListener = Listener;
Nico Weber824285e2014-05-08 04:26:47 +0000657 OwnsDeserializationListener = TakeOwnership;
Guy Benyei11169dd2012-12-18 14:30:41 +0000658}
659
660
661
662unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
663 return serialization::ComputeHash(Sel);
664}
665
666
667std::pair<unsigned, unsigned>
668ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000669 using namespace llvm::support;
670 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
671 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
Guy Benyei11169dd2012-12-18 14:30:41 +0000672 return std::make_pair(KeyLen, DataLen);
673}
674
675ASTSelectorLookupTrait::internal_key_type
676ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000677 using namespace llvm::support;
Guy Benyei11169dd2012-12-18 14:30:41 +0000678 SelectorTable &SelTable = Reader.getContext().Selectors;
Justin Bogner57ba0b22014-03-28 22:03:24 +0000679 unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
680 IdentifierInfo *FirstII = Reader.getLocalIdentifier(
681 F, endian::readNext<uint32_t, little, unaligned>(d));
Guy Benyei11169dd2012-12-18 14:30:41 +0000682 if (N == 0)
683 return SelTable.getNullarySelector(FirstII);
684 else if (N == 1)
685 return SelTable.getUnarySelector(FirstII);
686
687 SmallVector<IdentifierInfo *, 16> Args;
688 Args.push_back(FirstII);
689 for (unsigned I = 1; I != N; ++I)
Justin Bogner57ba0b22014-03-28 22:03:24 +0000690 Args.push_back(Reader.getLocalIdentifier(
691 F, endian::readNext<uint32_t, little, unaligned>(d)));
Guy Benyei11169dd2012-12-18 14:30:41 +0000692
693 return SelTable.getSelector(N, Args.data());
694}
695
696ASTSelectorLookupTrait::data_type
697ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
698 unsigned DataLen) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000699 using namespace llvm::support;
Guy Benyei11169dd2012-12-18 14:30:41 +0000700
701 data_type Result;
702
Justin Bogner57ba0b22014-03-28 22:03:24 +0000703 Result.ID = Reader.getGlobalSelectorID(
704 F, endian::readNext<uint32_t, little, unaligned>(d));
Nico Weberff4b35e2014-12-27 22:14:15 +0000705 unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
706 unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
707 Result.InstanceBits = FullInstanceBits & 0x3;
708 Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
709 Result.FactoryBits = FullFactoryBits & 0x3;
710 Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
711 unsigned NumInstanceMethods = FullInstanceBits >> 3;
712 unsigned NumFactoryMethods = FullFactoryBits >> 3;
Guy Benyei11169dd2012-12-18 14:30:41 +0000713
714 // Load instance methods
715 for (unsigned I = 0; I != NumInstanceMethods; ++I) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000716 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
717 F, endian::readNext<uint32_t, little, unaligned>(d)))
Guy Benyei11169dd2012-12-18 14:30:41 +0000718 Result.Instance.push_back(Method);
719 }
720
721 // Load factory methods
722 for (unsigned I = 0; I != NumFactoryMethods; ++I) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000723 if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
724 F, endian::readNext<uint32_t, little, unaligned>(d)))
Guy Benyei11169dd2012-12-18 14:30:41 +0000725 Result.Factory.push_back(Method);
726 }
727
728 return Result;
729}
730
Douglas Gregorbfd73d72013-01-23 18:53:14 +0000731unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
732 return llvm::HashString(a);
Guy Benyei11169dd2012-12-18 14:30:41 +0000733}
734
735std::pair<unsigned, unsigned>
Douglas Gregorbfd73d72013-01-23 18:53:14 +0000736ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000737 using namespace llvm::support;
738 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
739 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
Guy Benyei11169dd2012-12-18 14:30:41 +0000740 return std::make_pair(KeyLen, DataLen);
741}
742
Douglas Gregorbfd73d72013-01-23 18:53:14 +0000743ASTIdentifierLookupTraitBase::internal_key_type
744ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000745 assert(n >= 2 && d[n-1] == '\0');
Douglas Gregorbfd73d72013-01-23 18:53:14 +0000746 return StringRef((const char*) d, n-1);
Guy Benyei11169dd2012-12-18 14:30:41 +0000747}
748
Douglas Gregordcf25082013-02-11 18:16:18 +0000749/// \brief Whether the given identifier is "interesting".
Richard Smitha534a312015-07-21 23:54:07 +0000750static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
751 bool IsModule) {
Richard Smithcab89802015-07-17 20:19:56 +0000752 return II.hadMacroDefinition() ||
753 II.isPoisoned() ||
Richard Smith9c254182015-07-19 21:41:12 +0000754 (IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
Douglas Gregordcf25082013-02-11 18:16:18 +0000755 II.hasRevertedTokenIDToIdentifier() ||
Richard Smitha534a312015-07-21 23:54:07 +0000756 (!(IsModule && Reader.getContext().getLangOpts().CPlusPlus) &&
757 II.getFETokenInfo<void>());
Douglas Gregordcf25082013-02-11 18:16:18 +0000758}
759
Richard Smith76c2f2c2015-07-17 20:09:43 +0000760static bool readBit(unsigned &Bits) {
761 bool Value = Bits & 0x1;
762 Bits >>= 1;
763 return Value;
764}
765
Richard Smith79bf9202015-08-24 03:33:22 +0000766IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
767 using namespace llvm::support;
768 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
769 return Reader.getGlobalIdentifierID(F, RawID >> 1);
770}
771
Richard Smitheb4b58f62016-02-05 01:40:54 +0000772static void markIdentifierFromAST(ASTReader &Reader, IdentifierInfo &II) {
773 if (!II.isFromAST()) {
774 II.setIsFromAST();
775 bool IsModule = Reader.getPreprocessor().getCurrentModule() != nullptr;
776 if (isInterestingIdentifier(Reader, II, IsModule))
777 II.setChangedSinceDeserialization();
778 }
779}
780
Guy Benyei11169dd2012-12-18 14:30:41 +0000781IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
782 const unsigned char* d,
783 unsigned DataLen) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000784 using namespace llvm::support;
785 unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
Guy Benyei11169dd2012-12-18 14:30:41 +0000786 bool IsInteresting = RawID & 0x01;
787
788 // Wipe out the "is interesting" bit.
789 RawID = RawID >> 1;
790
Richard Smith76c2f2c2015-07-17 20:09:43 +0000791 // Build the IdentifierInfo and link the identifier ID with it.
792 IdentifierInfo *II = KnownII;
793 if (!II) {
794 II = &Reader.getIdentifierTable().getOwn(k);
795 KnownII = II;
796 }
Richard Smitheb4b58f62016-02-05 01:40:54 +0000797 markIdentifierFromAST(Reader, *II);
Richard Smith76c2f2c2015-07-17 20:09:43 +0000798 Reader.markIdentifierUpToDate(II);
799
Guy Benyei11169dd2012-12-18 14:30:41 +0000800 IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
801 if (!IsInteresting) {
Richard Smith76c2f2c2015-07-17 20:09:43 +0000802 // For uninteresting identifiers, there's nothing else to do. Just notify
803 // the reader that we've finished loading this identifier.
Guy Benyei11169dd2012-12-18 14:30:41 +0000804 Reader.SetIdentifierInfo(ID, II);
Guy Benyei11169dd2012-12-18 14:30:41 +0000805 return II;
806 }
807
Justin Bogner57ba0b22014-03-28 22:03:24 +0000808 unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
809 unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
Richard Smith76c2f2c2015-07-17 20:09:43 +0000810 bool CPlusPlusOperatorKeyword = readBit(Bits);
811 bool HasRevertedTokenIDToIdentifier = readBit(Bits);
Richard Smith9c254182015-07-19 21:41:12 +0000812 bool HasRevertedBuiltin = readBit(Bits);
Richard Smith76c2f2c2015-07-17 20:09:43 +0000813 bool Poisoned = readBit(Bits);
814 bool ExtensionToken = readBit(Bits);
815 bool HadMacroDefinition = readBit(Bits);
Guy Benyei11169dd2012-12-18 14:30:41 +0000816
817 assert(Bits == 0 && "Extra bits in the identifier?");
818 DataLen -= 8;
819
Guy Benyei11169dd2012-12-18 14:30:41 +0000820 // Set or check the various bits in the IdentifierInfo structure.
821 // Token IDs are read-only.
Argyrios Kyrtzidisddee8c92013-02-27 01:13:51 +0000822 if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
Richard Smith9c254182015-07-19 21:41:12 +0000823 II->revertTokenIDToIdentifier();
824 if (!F.isModule())
825 II->setObjCOrBuiltinID(ObjCOrBuiltinID);
826 else if (HasRevertedBuiltin && II->getBuiltinID()) {
827 II->revertBuiltin();
828 assert((II->hasRevertedBuiltin() ||
829 II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
830 "Incorrect ObjC keyword or builtin ID");
831 }
Guy Benyei11169dd2012-12-18 14:30:41 +0000832 assert(II->isExtensionToken() == ExtensionToken &&
833 "Incorrect extension token flag");
834 (void)ExtensionToken;
835 if (Poisoned)
836 II->setIsPoisoned(true);
837 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
838 "Incorrect C++ operator keyword flag");
839 (void)CPlusPlusOperatorKeyword;
840
841 // If this identifier is a macro, deserialize the macro
842 // definition.
Richard Smith76c2f2c2015-07-17 20:09:43 +0000843 if (HadMacroDefinition) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000844 uint32_t MacroDirectivesOffset =
845 endian::readNext<uint32_t, little, unaligned>(d);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +0000846 DataLen -= 4;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +0000847
Richard Smithd7329392015-04-21 21:46:32 +0000848 Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
Guy Benyei11169dd2012-12-18 14:30:41 +0000849 }
850
851 Reader.SetIdentifierInfo(ID, II);
852
853 // Read all of the declarations visible at global scope with this
854 // name.
855 if (DataLen > 0) {
856 SmallVector<uint32_t, 4> DeclIDs;
857 for (; DataLen > 0; DataLen -= 4)
Justin Bogner57ba0b22014-03-28 22:03:24 +0000858 DeclIDs.push_back(Reader.getGlobalDeclID(
859 F, endian::readNext<uint32_t, little, unaligned>(d)));
Guy Benyei11169dd2012-12-18 14:30:41 +0000860 Reader.SetGloballyVisibleDecls(II, DeclIDs);
861 }
862
863 return II;
864}
865
Richard Smitha06c7e62015-08-26 23:55:49 +0000866DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
867 : Kind(Name.getNameKind()) {
868 switch (Kind) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000869 case DeclarationName::Identifier:
Richard Smitha06c7e62015-08-26 23:55:49 +0000870 Data = (uint64_t)Name.getAsIdentifierInfo();
Guy Benyei11169dd2012-12-18 14:30:41 +0000871 break;
872 case DeclarationName::ObjCZeroArgSelector:
873 case DeclarationName::ObjCOneArgSelector:
874 case DeclarationName::ObjCMultiArgSelector:
Richard Smitha06c7e62015-08-26 23:55:49 +0000875 Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
Guy Benyei11169dd2012-12-18 14:30:41 +0000876 break;
877 case DeclarationName::CXXOperatorName:
Richard Smitha06c7e62015-08-26 23:55:49 +0000878 Data = Name.getCXXOverloadedOperator();
879 break;
880 case DeclarationName::CXXLiteralOperatorName:
881 Data = (uint64_t)Name.getCXXLiteralIdentifier();
882 break;
883 case DeclarationName::CXXConstructorName:
884 case DeclarationName::CXXDestructorName:
885 case DeclarationName::CXXConversionFunctionName:
886 case DeclarationName::CXXUsingDirective:
887 Data = 0;
888 break;
889 }
890}
891
892unsigned DeclarationNameKey::getHash() const {
893 llvm::FoldingSetNodeID ID;
894 ID.AddInteger(Kind);
895
896 switch (Kind) {
897 case DeclarationName::Identifier:
898 case DeclarationName::CXXLiteralOperatorName:
899 ID.AddString(((IdentifierInfo*)Data)->getName());
900 break;
901 case DeclarationName::ObjCZeroArgSelector:
902 case DeclarationName::ObjCOneArgSelector:
903 case DeclarationName::ObjCMultiArgSelector:
904 ID.AddInteger(serialization::ComputeHash(Selector(Data)));
905 break;
906 case DeclarationName::CXXOperatorName:
907 ID.AddInteger((OverloadedOperatorKind)Data);
Guy Benyei11169dd2012-12-18 14:30:41 +0000908 break;
909 case DeclarationName::CXXConstructorName:
910 case DeclarationName::CXXDestructorName:
911 case DeclarationName::CXXConversionFunctionName:
912 case DeclarationName::CXXUsingDirective:
913 break;
914 }
915
916 return ID.ComputeHash();
917}
918
Richard Smithd88a7f12015-09-01 20:35:42 +0000919ModuleFile *
920ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
921 using namespace llvm::support;
922 uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
923 return Reader.getLocalModuleFile(F, ModuleFileID);
924}
925
Guy Benyei11169dd2012-12-18 14:30:41 +0000926std::pair<unsigned, unsigned>
Richard Smitha06c7e62015-08-26 23:55:49 +0000927ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000928 using namespace llvm::support;
929 unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
930 unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
Guy Benyei11169dd2012-12-18 14:30:41 +0000931 return std::make_pair(KeyLen, DataLen);
932}
933
Richard Smitha06c7e62015-08-26 23:55:49 +0000934ASTDeclContextNameLookupTrait::internal_key_type
935ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000936 using namespace llvm::support;
Guy Benyei11169dd2012-12-18 14:30:41 +0000937
Richard Smitha06c7e62015-08-26 23:55:49 +0000938 auto Kind = (DeclarationName::NameKind)*d++;
939 uint64_t Data;
940 switch (Kind) {
Guy Benyei11169dd2012-12-18 14:30:41 +0000941 case DeclarationName::Identifier:
Richard Smitha06c7e62015-08-26 23:55:49 +0000942 Data = (uint64_t)Reader.getLocalIdentifier(
Justin Bogner57ba0b22014-03-28 22:03:24 +0000943 F, endian::readNext<uint32_t, little, unaligned>(d));
Guy Benyei11169dd2012-12-18 14:30:41 +0000944 break;
945 case DeclarationName::ObjCZeroArgSelector:
946 case DeclarationName::ObjCOneArgSelector:
947 case DeclarationName::ObjCMultiArgSelector:
Richard Smitha06c7e62015-08-26 23:55:49 +0000948 Data =
Justin Bogner57ba0b22014-03-28 22:03:24 +0000949 (uint64_t)Reader.getLocalSelector(
950 F, endian::readNext<uint32_t, little, unaligned>(
951 d)).getAsOpaquePtr();
Guy Benyei11169dd2012-12-18 14:30:41 +0000952 break;
953 case DeclarationName::CXXOperatorName:
Richard Smitha06c7e62015-08-26 23:55:49 +0000954 Data = *d++; // OverloadedOperatorKind
Guy Benyei11169dd2012-12-18 14:30:41 +0000955 break;
956 case DeclarationName::CXXLiteralOperatorName:
Richard Smitha06c7e62015-08-26 23:55:49 +0000957 Data = (uint64_t)Reader.getLocalIdentifier(
Justin Bogner57ba0b22014-03-28 22:03:24 +0000958 F, endian::readNext<uint32_t, little, unaligned>(d));
Guy Benyei11169dd2012-12-18 14:30:41 +0000959 break;
960 case DeclarationName::CXXConstructorName:
961 case DeclarationName::CXXDestructorName:
962 case DeclarationName::CXXConversionFunctionName:
963 case DeclarationName::CXXUsingDirective:
Richard Smitha06c7e62015-08-26 23:55:49 +0000964 Data = 0;
Guy Benyei11169dd2012-12-18 14:30:41 +0000965 break;
966 }
967
Richard Smitha06c7e62015-08-26 23:55:49 +0000968 return DeclarationNameKey(Kind, Data);
Guy Benyei11169dd2012-12-18 14:30:41 +0000969}
970
Richard Smithd88a7f12015-09-01 20:35:42 +0000971void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
972 const unsigned char *d,
973 unsigned DataLen,
974 data_type_builder &Val) {
Justin Bogner57ba0b22014-03-28 22:03:24 +0000975 using namespace llvm::support;
Richard Smithd88a7f12015-09-01 20:35:42 +0000976 for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
977 uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
978 Val.insert(Reader.getGlobalDeclID(F, LocalID));
979 }
Guy Benyei11169dd2012-12-18 14:30:41 +0000980}
981
Richard Smith0f4e2c42015-08-06 04:23:48 +0000982bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
983 BitstreamCursor &Cursor,
984 uint64_t Offset,
985 DeclContext *DC) {
986 assert(Offset != 0);
987
Guy Benyei11169dd2012-12-18 14:30:41 +0000988 SavedStreamPosition SavedPosition(Cursor);
Richard Smith0f4e2c42015-08-06 04:23:48 +0000989 Cursor.JumpToBit(Offset);
Guy Benyei11169dd2012-12-18 14:30:41 +0000990
Richard Smith0f4e2c42015-08-06 04:23:48 +0000991 RecordData Record;
992 StringRef Blob;
993 unsigned Code = Cursor.ReadCode();
994 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
995 if (RecCode != DECL_CONTEXT_LEXICAL) {
996 Error("Expected lexical block");
997 return true;
Guy Benyei11169dd2012-12-18 14:30:41 +0000998 }
999
Richard Smith82f8fcd2015-08-06 22:07:25 +00001000 assert(!isa<TranslationUnitDecl>(DC) &&
1001 "expected a TU_UPDATE_LEXICAL record for TU");
Richard Smith9c9173d2015-08-11 22:00:24 +00001002 // If we are handling a C++ class template instantiation, we can see multiple
1003 // lexical updates for the same record. It's important that we select only one
1004 // of them, so that field numbering works properly. Just pick the first one we
1005 // see.
1006 auto &Lex = LexicalDecls[DC];
1007 if (!Lex.first) {
1008 Lex = std::make_pair(
1009 &M, llvm::makeArrayRef(
1010 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
1011 Blob.data()),
1012 Blob.size() / 4));
1013 }
Richard Smith0f4e2c42015-08-06 04:23:48 +00001014 DC->setHasExternalLexicalStorage(true);
1015 return false;
1016}
Guy Benyei11169dd2012-12-18 14:30:41 +00001017
Richard Smith0f4e2c42015-08-06 04:23:48 +00001018bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
1019 BitstreamCursor &Cursor,
1020 uint64_t Offset,
1021 DeclID ID) {
1022 assert(Offset != 0);
1023
1024 SavedStreamPosition SavedPosition(Cursor);
1025 Cursor.JumpToBit(Offset);
1026
1027 RecordData Record;
1028 StringRef Blob;
1029 unsigned Code = Cursor.ReadCode();
1030 unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
1031 if (RecCode != DECL_CONTEXT_VISIBLE) {
1032 Error("Expected visible lookup table block");
1033 return true;
Guy Benyei11169dd2012-12-18 14:30:41 +00001034 }
1035
Richard Smith0f4e2c42015-08-06 04:23:48 +00001036 // We can't safely determine the primary context yet, so delay attaching the
1037 // lookup table until we're done with recursive deserialization.
Richard Smithd88a7f12015-09-01 20:35:42 +00001038 auto *Data = (const unsigned char*)Blob.data();
1039 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
Guy Benyei11169dd2012-12-18 14:30:41 +00001040 return false;
1041}
1042
1043void ASTReader::Error(StringRef Msg) {
1044 Error(diag::err_fe_pch_malformed, Msg);
Richard Smithfb1e7f72015-08-14 05:02:58 +00001045 if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
1046 !PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
Douglas Gregor940e8052013-05-10 22:15:13 +00001047 Diag(diag::note_module_cache_path)
1048 << PP.getHeaderSearchInfo().getModuleCachePath();
1049 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001050}
1051
1052void ASTReader::Error(unsigned DiagID,
1053 StringRef Arg1, StringRef Arg2) {
1054 if (Diags.isDiagnosticInFlight())
1055 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
1056 else
1057 Diag(DiagID) << Arg1 << Arg2;
1058}
1059
1060//===----------------------------------------------------------------------===//
1061// Source Manager Deserialization
1062//===----------------------------------------------------------------------===//
1063
1064/// \brief Read the line table in the source manager block.
1065/// \returns true if there was an error.
1066bool ASTReader::ParseLineTable(ModuleFile &F,
Richard Smith7ed1bc92014-12-05 22:42:13 +00001067 const RecordData &Record) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001068 unsigned Idx = 0;
1069 LineTableInfo &LineTable = SourceMgr.getLineTable();
1070
1071 // Parse the file names
1072 std::map<int, int> FileIDs;
Richard Smith63078492015-09-01 07:41:55 +00001073 for (unsigned I = 0; Record[Idx]; ++I) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001074 // Extract the file name
Richard Smith7ed1bc92014-12-05 22:42:13 +00001075 auto Filename = ReadPath(F, Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00001076 FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
1077 }
Richard Smith63078492015-09-01 07:41:55 +00001078 ++Idx;
Guy Benyei11169dd2012-12-18 14:30:41 +00001079
1080 // Parse the line entries
1081 std::vector<LineEntry> Entries;
1082 while (Idx < Record.size()) {
1083 int FID = Record[Idx++];
1084 assert(FID >= 0 && "Serialized line entries for non-local file.");
1085 // Remap FileID from 1-based old view.
1086 FID += F.SLocEntryBaseID - 1;
1087
1088 // Extract the line entries
1089 unsigned NumEntries = Record[Idx++];
Richard Smith63078492015-09-01 07:41:55 +00001090 assert(NumEntries && "no line entries for file ID");
Guy Benyei11169dd2012-12-18 14:30:41 +00001091 Entries.clear();
1092 Entries.reserve(NumEntries);
1093 for (unsigned I = 0; I != NumEntries; ++I) {
1094 unsigned FileOffset = Record[Idx++];
1095 unsigned LineNo = Record[Idx++];
1096 int FilenameID = FileIDs[Record[Idx++]];
1097 SrcMgr::CharacteristicKind FileKind
1098 = (SrcMgr::CharacteristicKind)Record[Idx++];
1099 unsigned IncludeOffset = Record[Idx++];
1100 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
1101 FileKind, IncludeOffset));
1102 }
1103 LineTable.AddEntry(FileID::get(FID), Entries);
1104 }
1105
1106 return false;
1107}
1108
1109/// \brief Read a source manager block
1110bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
1111 using namespace SrcMgr;
1112
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001113 BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00001114
1115 // Set the source-location entry cursor to the current position in
1116 // the stream. This cursor will be used to read the contents of the
1117 // source manager block initially, and then lazily read
1118 // source-location entries as needed.
1119 SLocEntryCursor = F.Stream;
1120
1121 // The stream itself is going to skip over the source manager block.
1122 if (F.Stream.SkipBlock()) {
1123 Error("malformed block record in AST file");
1124 return true;
1125 }
1126
1127 // Enter the source manager block.
1128 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
1129 Error("malformed source manager block record in AST file");
1130 return true;
1131 }
1132
1133 RecordData Record;
1134 while (true) {
Chris Lattnere7b154b2013-01-19 21:39:22 +00001135 llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
1136
1137 switch (E.Kind) {
1138 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1139 case llvm::BitstreamEntry::Error:
1140 Error("malformed block record in AST file");
1141 return true;
1142 case llvm::BitstreamEntry::EndBlock:
Guy Benyei11169dd2012-12-18 14:30:41 +00001143 return false;
Chris Lattnere7b154b2013-01-19 21:39:22 +00001144 case llvm::BitstreamEntry::Record:
1145 // The interesting case.
1146 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00001147 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00001148
Guy Benyei11169dd2012-12-18 14:30:41 +00001149 // Read a record.
Guy Benyei11169dd2012-12-18 14:30:41 +00001150 Record.clear();
Chris Lattner15c3e7d2013-01-21 18:28:26 +00001151 StringRef Blob;
1152 switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001153 default: // Default behavior: ignore.
1154 break;
1155
1156 case SM_SLOC_FILE_ENTRY:
1157 case SM_SLOC_BUFFER_ENTRY:
1158 case SM_SLOC_EXPANSION_ENTRY:
1159 // Once we hit one of the source location entries, we're done.
1160 return false;
1161 }
1162 }
1163}
1164
1165/// \brief If a header file is not found at the path that we expect it to be
1166/// and the PCH file was moved from its original location, try to resolve the
1167/// file by assuming that header+PCH were moved together and the header is in
1168/// the same place relative to the PCH.
1169static std::string
1170resolveFileRelativeToOriginalDir(const std::string &Filename,
1171 const std::string &OriginalDir,
1172 const std::string &CurrDir) {
1173 assert(OriginalDir != CurrDir &&
1174 "No point trying to resolve the file if the PCH dir didn't change");
1175 using namespace llvm::sys;
1176 SmallString<128> filePath(Filename);
1177 fs::make_absolute(filePath);
1178 assert(path::is_absolute(OriginalDir));
1179 SmallString<128> currPCHPath(CurrDir);
1180
1181 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
1182 fileDirE = path::end(path::parent_path(filePath));
1183 path::const_iterator origDirI = path::begin(OriginalDir),
1184 origDirE = path::end(OriginalDir);
1185 // Skip the common path components from filePath and OriginalDir.
1186 while (fileDirI != fileDirE && origDirI != origDirE &&
1187 *fileDirI == *origDirI) {
1188 ++fileDirI;
1189 ++origDirI;
1190 }
1191 for (; origDirI != origDirE; ++origDirI)
1192 path::append(currPCHPath, "..");
1193 path::append(currPCHPath, fileDirI, fileDirE);
1194 path::append(currPCHPath, path::filename(Filename));
1195 return currPCHPath.str();
1196}
1197
1198bool ASTReader::ReadSLocEntry(int ID) {
1199 if (ID == 0)
1200 return false;
1201
1202 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1203 Error("source location entry ID out-of-range for AST file");
1204 return true;
1205 }
1206
Richard Smithaada85c2016-02-06 02:06:43 +00001207 // Local helper to read the (possibly-compressed) buffer data following the
1208 // entry record.
1209 auto ReadBuffer = [this](
1210 BitstreamCursor &SLocEntryCursor,
1211 StringRef Name) -> std::unique_ptr<llvm::MemoryBuffer> {
1212 RecordData Record;
1213 StringRef Blob;
1214 unsigned Code = SLocEntryCursor.ReadCode();
1215 unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
1216
1217 if (RecCode == SM_SLOC_BUFFER_BLOB_COMPRESSED) {
1218 SmallString<0> Uncompressed;
1219 if (llvm::zlib::uncompress(Blob, Uncompressed, Record[0]) !=
1220 llvm::zlib::StatusOK) {
1221 Error("could not decompress embedded file contents");
1222 return nullptr;
1223 }
1224 return llvm::MemoryBuffer::getMemBufferCopy(Uncompressed, Name);
1225 } else if (RecCode == SM_SLOC_BUFFER_BLOB) {
1226 return llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name, true);
1227 } else {
1228 Error("AST record has invalid code");
1229 return nullptr;
1230 }
1231 };
1232
Guy Benyei11169dd2012-12-18 14:30:41 +00001233 ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
1234 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001235 BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00001236 unsigned BaseOffset = F->SLocEntryBaseOffset;
1237
1238 ++NumSLocEntriesRead;
Chris Lattnere7b154b2013-01-19 21:39:22 +00001239 llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
1240 if (Entry.Kind != llvm::BitstreamEntry::Record) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001241 Error("incorrectly-formatted source location entry in AST file");
1242 return true;
1243 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00001244
Guy Benyei11169dd2012-12-18 14:30:41 +00001245 RecordData Record;
Chris Lattner0e6c9402013-01-20 02:38:54 +00001246 StringRef Blob;
1247 switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001248 default:
1249 Error("incorrectly-formatted source location entry in AST file");
1250 return true;
1251
1252 case SM_SLOC_FILE_ENTRY: {
1253 // We will detect whether a file changed and return 'Failure' for it, but
1254 // we will also try to fail gracefully by setting up the SLocEntry.
1255 unsigned InputID = Record[4];
1256 InputFile IF = getInputFile(*F, InputID);
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00001257 const FileEntry *File = IF.getFile();
1258 bool OverriddenBuffer = IF.isOverridden();
Guy Benyei11169dd2012-12-18 14:30:41 +00001259
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00001260 // Note that we only check if a File was returned. If it was out-of-date
1261 // we have complained but we will continue creating a FileID to recover
1262 // gracefully.
1263 if (!File)
Guy Benyei11169dd2012-12-18 14:30:41 +00001264 return true;
1265
1266 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
1267 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
1268 // This is the module's main file.
1269 IncludeLoc = getImportLocation(F);
1270 }
1271 SrcMgr::CharacteristicKind
1272 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1273 FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
1274 ID, BaseOffset + Record[0]);
1275 SrcMgr::FileInfo &FileInfo =
1276 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
1277 FileInfo.NumCreatedFIDs = Record[5];
1278 if (Record[3])
1279 FileInfo.setHasLineDirectives();
1280
1281 const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
1282 unsigned NumFileDecls = Record[7];
1283 if (NumFileDecls) {
1284 assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
1285 FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
1286 NumFileDecls));
1287 }
Richard Smithaada85c2016-02-06 02:06:43 +00001288
Guy Benyei11169dd2012-12-18 14:30:41 +00001289 const SrcMgr::ContentCache *ContentCache
1290 = SourceMgr.getOrCreateContentCache(File,
1291 /*isSystemFile=*/FileCharacter != SrcMgr::C_User);
1292 if (OverriddenBuffer && !ContentCache->BufferOverridden &&
Richard Smitha8cfffa2015-11-26 02:04:16 +00001293 ContentCache->ContentsEntry == ContentCache->OrigEntry &&
1294 !ContentCache->getRawBuffer()) {
Richard Smithaada85c2016-02-06 02:06:43 +00001295 auto Buffer = ReadBuffer(SLocEntryCursor, File->getName());
1296 if (!Buffer)
Guy Benyei11169dd2012-12-18 14:30:41 +00001297 return true;
David Blaikie49cc3182014-08-27 20:54:45 +00001298 SourceMgr.overrideFileContents(File, std::move(Buffer));
Guy Benyei11169dd2012-12-18 14:30:41 +00001299 }
1300
1301 break;
1302 }
1303
1304 case SM_SLOC_BUFFER_ENTRY: {
Chris Lattner0e6c9402013-01-20 02:38:54 +00001305 const char *Name = Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00001306 unsigned Offset = Record[0];
1307 SrcMgr::CharacteristicKind
1308 FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
1309 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
Richard Smithe842a472014-10-22 02:05:46 +00001310 if (IncludeLoc.isInvalid() &&
1311 (F->Kind == MK_ImplicitModule || F->Kind == MK_ExplicitModule)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001312 IncludeLoc = getImportLocation(F);
1313 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001314
Richard Smithaada85c2016-02-06 02:06:43 +00001315 auto Buffer = ReadBuffer(SLocEntryCursor, Name);
1316 if (!Buffer)
Guy Benyei11169dd2012-12-18 14:30:41 +00001317 return true;
David Blaikie50a5f972014-08-29 07:59:55 +00001318 SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
Rafael Espindolad87f8d72014-08-27 20:03:29 +00001319 BaseOffset + Offset, IncludeLoc);
Guy Benyei11169dd2012-12-18 14:30:41 +00001320 break;
1321 }
1322
1323 case SM_SLOC_EXPANSION_ENTRY: {
1324 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
1325 SourceMgr.createExpansionLoc(SpellingLoc,
1326 ReadSourceLocation(*F, Record[2]),
1327 ReadSourceLocation(*F, Record[3]),
1328 Record[4],
1329 ID,
1330 BaseOffset + Record[0]);
1331 break;
1332 }
1333 }
1334
1335 return false;
1336}
1337
1338std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
1339 if (ID == 0)
1340 return std::make_pair(SourceLocation(), "");
1341
1342 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
1343 Error("source location entry ID out-of-range for AST file");
1344 return std::make_pair(SourceLocation(), "");
1345 }
1346
1347 // Find which module file this entry lands in.
1348 ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
Richard Smithe842a472014-10-22 02:05:46 +00001349 if (M->Kind != MK_ImplicitModule && M->Kind != MK_ExplicitModule)
Guy Benyei11169dd2012-12-18 14:30:41 +00001350 return std::make_pair(SourceLocation(), "");
1351
1352 // FIXME: Can we map this down to a particular submodule? That would be
1353 // ideal.
Ben Langmuirbeee15e2014-04-14 18:00:01 +00001354 return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
Guy Benyei11169dd2012-12-18 14:30:41 +00001355}
1356
1357/// \brief Find the location where the module F is imported.
1358SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
1359 if (F->ImportLoc.isValid())
1360 return F->ImportLoc;
1361
1362 // Otherwise we have a PCH. It's considered to be "imported" at the first
1363 // location of its includer.
1364 if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
Ben Langmuirbeee15e2014-04-14 18:00:01 +00001365 // Main file is the importer.
Yaron Keren8b563662015-10-03 10:46:20 +00001366 assert(SourceMgr.getMainFileID().isValid() && "missing main file");
Ben Langmuirbeee15e2014-04-14 18:00:01 +00001367 return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
Guy Benyei11169dd2012-12-18 14:30:41 +00001368 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001369 return F->ImportedBy[0]->FirstLoc;
1370}
1371
1372/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the
1373/// specified cursor. Read the abbreviations that are at the top of the block
1374/// and then leave the cursor pointing into the block.
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001375bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
Richard Smith0516b182015-09-08 19:40:14 +00001376 if (Cursor.EnterSubBlock(BlockID))
1377 return true;
Guy Benyei11169dd2012-12-18 14:30:41 +00001378
1379 while (true) {
1380 uint64_t Offset = Cursor.GetCurrentBitNo();
1381 unsigned Code = Cursor.ReadCode();
1382
1383 // We expect all abbrevs to be at the start of the block.
1384 if (Code != llvm::bitc::DEFINE_ABBREV) {
1385 Cursor.JumpToBit(Offset);
1386 return false;
1387 }
1388 Cursor.ReadAbbrevRecord();
1389 }
1390}
1391
Richard Smithe40f2ba2013-08-07 21:41:30 +00001392Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
John McCallf413f5e2013-05-03 00:10:13 +00001393 unsigned &Idx) {
1394 Token Tok;
1395 Tok.startToken();
1396 Tok.setLocation(ReadSourceLocation(F, Record, Idx));
1397 Tok.setLength(Record[Idx++]);
1398 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1399 Tok.setIdentifierInfo(II);
1400 Tok.setKind((tok::TokenKind)Record[Idx++]);
1401 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
1402 return Tok;
1403}
1404
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001405MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001406 BitstreamCursor &Stream = F.MacroCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00001407
1408 // Keep track of where we are in the stream, then jump back there
1409 // after reading this macro.
1410 SavedStreamPosition SavedPosition(Stream);
1411
1412 Stream.JumpToBit(Offset);
1413 RecordData Record;
1414 SmallVector<IdentifierInfo*, 16> MacroArgs;
Craig Toppera13603a2014-05-22 05:54:18 +00001415 MacroInfo *Macro = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00001416
Guy Benyei11169dd2012-12-18 14:30:41 +00001417 while (true) {
Chris Lattnerefa77172013-01-20 00:00:22 +00001418 // Advance to the next record, but if we get to the end of the block, don't
1419 // pop it (removing all the abbreviations from the cursor) since we want to
1420 // be able to reseek within the block and read entries.
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001421 unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
Chris Lattnerefa77172013-01-20 00:00:22 +00001422 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
1423
1424 switch (Entry.Kind) {
1425 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1426 case llvm::BitstreamEntry::Error:
1427 Error("malformed block record in AST file");
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001428 return Macro;
Chris Lattnerefa77172013-01-20 00:00:22 +00001429 case llvm::BitstreamEntry::EndBlock:
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001430 return Macro;
Chris Lattnerefa77172013-01-20 00:00:22 +00001431 case llvm::BitstreamEntry::Record:
1432 // The interesting case.
1433 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00001434 }
1435
1436 // Read a record.
Guy Benyei11169dd2012-12-18 14:30:41 +00001437 Record.clear();
1438 PreprocessorRecordTypes RecType =
Chris Lattner0e6c9402013-01-20 02:38:54 +00001439 (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
Guy Benyei11169dd2012-12-18 14:30:41 +00001440 switch (RecType) {
Richard Smithd7329392015-04-21 21:46:32 +00001441 case PP_MODULE_MACRO:
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001442 case PP_MACRO_DIRECTIVE_HISTORY:
1443 return Macro;
1444
Guy Benyei11169dd2012-12-18 14:30:41 +00001445 case PP_MACRO_OBJECT_LIKE:
1446 case PP_MACRO_FUNCTION_LIKE: {
1447 // If we already have a macro, that means that we've hit the end
1448 // of the definition of the macro we were looking for. We're
1449 // done.
1450 if (Macro)
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001451 return Macro;
Guy Benyei11169dd2012-12-18 14:30:41 +00001452
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001453 unsigned NextIndex = 1; // Skip identifier ID.
1454 SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]);
Guy Benyei11169dd2012-12-18 14:30:41 +00001455 SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001456 MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID);
Argyrios Kyrtzidis7572be22013-01-07 19:16:23 +00001457 MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
Guy Benyei11169dd2012-12-18 14:30:41 +00001458 MI->setIsUsed(Record[NextIndex++]);
Argyrios Kyrtzidis9ef53ce2014-04-09 18:21:23 +00001459 MI->setUsedForHeaderGuard(Record[NextIndex++]);
Guy Benyei11169dd2012-12-18 14:30:41 +00001460
Guy Benyei11169dd2012-12-18 14:30:41 +00001461 if (RecType == PP_MACRO_FUNCTION_LIKE) {
1462 // Decode function-like macro info.
1463 bool isC99VarArgs = Record[NextIndex++];
1464 bool isGNUVarArgs = Record[NextIndex++];
1465 bool hasCommaPasting = Record[NextIndex++];
1466 MacroArgs.clear();
1467 unsigned NumArgs = Record[NextIndex++];
1468 for (unsigned i = 0; i != NumArgs; ++i)
1469 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
1470
1471 // Install function-like macro info.
1472 MI->setIsFunctionLike();
1473 if (isC99VarArgs) MI->setIsC99Varargs();
1474 if (isGNUVarArgs) MI->setIsGNUVarargs();
1475 if (hasCommaPasting) MI->setHasCommaPasting();
Craig Topperd96b3f92015-10-22 04:59:52 +00001476 MI->setArgumentList(MacroArgs, PP.getPreprocessorAllocator());
Guy Benyei11169dd2012-12-18 14:30:41 +00001477 }
1478
Guy Benyei11169dd2012-12-18 14:30:41 +00001479 // Remember that we saw this macro last so that we add the tokens that
1480 // form its body to it.
1481 Macro = MI;
1482
1483 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
1484 Record[NextIndex]) {
1485 // We have a macro definition. Register the association
1486 PreprocessedEntityID
1487 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
1488 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
Richard Smith66a81862015-05-04 02:25:31 +00001489 PreprocessingRecord::PPEntityID PPID =
1490 PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
1491 MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
1492 PPRec.getPreprocessedEntity(PPID));
Argyrios Kyrtzidis832de9f2013-02-22 18:35:59 +00001493 if (PPDef)
1494 PPRec.RegisterMacroDefinition(Macro, PPDef);
Guy Benyei11169dd2012-12-18 14:30:41 +00001495 }
1496
1497 ++NumMacrosRead;
1498 break;
1499 }
1500
1501 case PP_TOKEN: {
1502 // If we see a TOKEN before a PP_MACRO_*, then the file is
1503 // erroneous, just pretend we didn't see this.
Craig Toppera13603a2014-05-22 05:54:18 +00001504 if (!Macro) break;
Guy Benyei11169dd2012-12-18 14:30:41 +00001505
John McCallf413f5e2013-05-03 00:10:13 +00001506 unsigned Idx = 0;
1507 Token Tok = ReadToken(F, Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00001508 Macro->AddTokenToBody(Tok);
1509 break;
1510 }
1511 }
1512 }
1513}
1514
1515PreprocessedEntityID
1516ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
1517 ContinuousRangeMap<uint32_t, int, 2>::const_iterator
1518 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
1519 assert(I != M.PreprocessedEntityRemap.end()
1520 && "Invalid index into preprocessed entity index remap");
1521
1522 return LocalID + I->second;
1523}
1524
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001525unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
1526 return llvm::hash_combine(ikey.Size, ikey.ModTime);
Guy Benyei11169dd2012-12-18 14:30:41 +00001527}
Richard Smith7ed1bc92014-12-05 22:42:13 +00001528
Guy Benyei11169dd2012-12-18 14:30:41 +00001529HeaderFileInfoTrait::internal_key_type
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001530HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
Richard Smithe75ee0f2015-08-17 07:13:32 +00001531 internal_key_type ikey = {FE->getSize(),
1532 M.HasTimestamps ? FE->getModificationTime() : 0,
1533 FE->getName(), /*Imported*/ false};
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001534 return ikey;
1535}
Guy Benyei11169dd2012-12-18 14:30:41 +00001536
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001537bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
Richard Smithe75ee0f2015-08-17 07:13:32 +00001538 if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
Guy Benyei11169dd2012-12-18 14:30:41 +00001539 return false;
1540
Richard Smith7ed1bc92014-12-05 22:42:13 +00001541 if (llvm::sys::path::is_absolute(a.Filename) &&
1542 strcmp(a.Filename, b.Filename) == 0)
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001543 return true;
1544
Guy Benyei11169dd2012-12-18 14:30:41 +00001545 // Determine whether the actual files are equivalent.
Argyrios Kyrtzidis2a513e82013-03-04 20:33:40 +00001546 FileManager &FileMgr = Reader.getFileManager();
Richard Smith7ed1bc92014-12-05 22:42:13 +00001547 auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
1548 if (!Key.Imported)
1549 return FileMgr.getFile(Key.Filename);
1550
1551 std::string Resolved = Key.Filename;
1552 Reader.ResolveImportedPath(M, Resolved);
1553 return FileMgr.getFile(Resolved);
1554 };
1555
1556 const FileEntry *FEA = GetFile(a);
1557 const FileEntry *FEB = GetFile(b);
1558 return FEA && FEA == FEB;
Guy Benyei11169dd2012-12-18 14:30:41 +00001559}
1560
1561std::pair<unsigned, unsigned>
1562HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
Justin Bogner57ba0b22014-03-28 22:03:24 +00001563 using namespace llvm::support;
1564 unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
Guy Benyei11169dd2012-12-18 14:30:41 +00001565 unsigned DataLen = (unsigned) *d++;
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001566 return std::make_pair(KeyLen, DataLen);
Guy Benyei11169dd2012-12-18 14:30:41 +00001567}
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001568
1569HeaderFileInfoTrait::internal_key_type
1570HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
Justin Bogner57ba0b22014-03-28 22:03:24 +00001571 using namespace llvm::support;
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001572 internal_key_type ikey;
Justin Bogner57ba0b22014-03-28 22:03:24 +00001573 ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
1574 ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001575 ikey.Filename = (const char *)d;
Richard Smith7ed1bc92014-12-05 22:42:13 +00001576 ikey.Imported = true;
Argyrios Kyrtzidis5c2a3452013-03-06 18:12:47 +00001577 return ikey;
1578}
1579
Guy Benyei11169dd2012-12-18 14:30:41 +00001580HeaderFileInfoTrait::data_type
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001581HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
Guy Benyei11169dd2012-12-18 14:30:41 +00001582 unsigned DataLen) {
1583 const unsigned char *End = d + DataLen;
Justin Bogner57ba0b22014-03-28 22:03:24 +00001584 using namespace llvm::support;
Guy Benyei11169dd2012-12-18 14:30:41 +00001585 HeaderFileInfo HFI;
1586 unsigned Flags = *d++;
Richard Smith386bb072015-08-18 23:42:23 +00001587 // FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
1588 HFI.isImport |= (Flags >> 4) & 0x01;
1589 HFI.isPragmaOnce |= (Flags >> 3) & 0x01;
1590 HFI.DirInfo = (Flags >> 1) & 0x03;
Guy Benyei11169dd2012-12-18 14:30:41 +00001591 HFI.IndexHeaderMapHeader = Flags & 0x01;
Richard Smith386bb072015-08-18 23:42:23 +00001592 // FIXME: Find a better way to handle this. Maybe just store a
1593 // "has been included" flag?
1594 HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
1595 HFI.NumIncludes);
Justin Bogner57ba0b22014-03-28 22:03:24 +00001596 HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
1597 M, endian::readNext<uint32_t, little, unaligned>(d));
1598 if (unsigned FrameworkOffset =
1599 endian::readNext<uint32_t, little, unaligned>(d)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001600 // The framework offset is 1 greater than the actual offset,
1601 // since 0 is used as an indicator for "no framework name".
1602 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
1603 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
1604 }
Richard Smith386bb072015-08-18 23:42:23 +00001605
1606 assert((End - d) % 4 == 0 &&
1607 "Wrong data length in HeaderFileInfo deserialization");
1608 while (d != End) {
Justin Bogner57ba0b22014-03-28 22:03:24 +00001609 uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
Richard Smith386bb072015-08-18 23:42:23 +00001610 auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
1611 LocalSMID >>= 2;
1612
1613 // This header is part of a module. Associate it with the module to enable
1614 // implicit module import.
1615 SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
1616 Module *Mod = Reader.getSubmodule(GlobalSMID);
1617 FileManager &FileMgr = Reader.getFileManager();
1618 ModuleMap &ModMap =
1619 Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
1620
1621 std::string Filename = key.Filename;
1622 if (key.Imported)
1623 Reader.ResolveImportedPath(M, Filename);
1624 // FIXME: This is not always the right filename-as-written, but we're not
1625 // going to use this information to rebuild the module, so it doesn't make
1626 // a lot of difference.
1627 Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
Richard Smithd8879c82015-08-24 21:59:32 +00001628 ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
1629 HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00001630 }
1631
Guy Benyei11169dd2012-12-18 14:30:41 +00001632 // This HeaderFileInfo was externally loaded.
1633 HFI.External = true;
Richard Smithd8879c82015-08-24 21:59:32 +00001634 HFI.IsValid = true;
Guy Benyei11169dd2012-12-18 14:30:41 +00001635 return HFI;
1636}
1637
Richard Smithd7329392015-04-21 21:46:32 +00001638void ASTReader::addPendingMacro(IdentifierInfo *II,
1639 ModuleFile *M,
1640 uint64_t MacroDirectivesOffset) {
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001641 assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
1642 PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
Guy Benyei11169dd2012-12-18 14:30:41 +00001643}
1644
1645void ASTReader::ReadDefinedMacros() {
1646 // Note that we are loading defined macros.
1647 Deserializing Macros(this);
1648
Pete Cooper57d3f142015-07-30 17:22:52 +00001649 for (auto &I : llvm::reverse(ModuleMgr)) {
1650 BitstreamCursor &MacroCursor = I->MacroCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00001651
1652 // If there was no preprocessor block, skip this file.
1653 if (!MacroCursor.getBitStreamReader())
1654 continue;
1655
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001656 BitstreamCursor Cursor = MacroCursor;
Pete Cooper57d3f142015-07-30 17:22:52 +00001657 Cursor.JumpToBit(I->MacroStartOffset);
Guy Benyei11169dd2012-12-18 14:30:41 +00001658
1659 RecordData Record;
1660 while (true) {
Chris Lattnere7b154b2013-01-19 21:39:22 +00001661 llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
1662
1663 switch (E.Kind) {
1664 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
1665 case llvm::BitstreamEntry::Error:
1666 Error("malformed block record in AST file");
1667 return;
1668 case llvm::BitstreamEntry::EndBlock:
1669 goto NextCursor;
1670
1671 case llvm::BitstreamEntry::Record:
Chris Lattnere7b154b2013-01-19 21:39:22 +00001672 Record.clear();
Chris Lattner0e6c9402013-01-20 02:38:54 +00001673 switch (Cursor.readRecord(E.ID, Record)) {
Chris Lattnere7b154b2013-01-19 21:39:22 +00001674 default: // Default behavior: ignore.
1675 break;
1676
1677 case PP_MACRO_OBJECT_LIKE:
1678 case PP_MACRO_FUNCTION_LIKE:
Pete Cooper57d3f142015-07-30 17:22:52 +00001679 getLocalIdentifier(*I, Record[0]);
Chris Lattnere7b154b2013-01-19 21:39:22 +00001680 break;
1681
1682 case PP_TOKEN:
1683 // Ignore tokens.
1684 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00001685 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001686 break;
1687 }
1688 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00001689 NextCursor: ;
Guy Benyei11169dd2012-12-18 14:30:41 +00001690 }
1691}
1692
1693namespace {
1694 /// \brief Visitor class used to look up identifirs in an AST file.
1695 class IdentifierLookupVisitor {
1696 StringRef Name;
Richard Smith3b637412015-07-14 18:42:41 +00001697 unsigned NameHash;
Guy Benyei11169dd2012-12-18 14:30:41 +00001698 unsigned PriorGeneration;
Douglas Gregor00a50f72013-01-25 00:38:33 +00001699 unsigned &NumIdentifierLookups;
1700 unsigned &NumIdentifierLookupHits;
Guy Benyei11169dd2012-12-18 14:30:41 +00001701 IdentifierInfo *Found;
Douglas Gregor00a50f72013-01-25 00:38:33 +00001702
Guy Benyei11169dd2012-12-18 14:30:41 +00001703 public:
Douglas Gregor00a50f72013-01-25 00:38:33 +00001704 IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
1705 unsigned &NumIdentifierLookups,
1706 unsigned &NumIdentifierLookupHits)
Richard Smith3b637412015-07-14 18:42:41 +00001707 : Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
1708 PriorGeneration(PriorGeneration),
Douglas Gregor00a50f72013-01-25 00:38:33 +00001709 NumIdentifierLookups(NumIdentifierLookups),
1710 NumIdentifierLookupHits(NumIdentifierLookupHits),
1711 Found()
1712 {
1713 }
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00001714
1715 bool operator()(ModuleFile &M) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001716 // If we've already searched this module file, skip it now.
Richard Smithbdf2d932015-07-30 03:37:16 +00001717 if (M.Generation <= PriorGeneration)
Guy Benyei11169dd2012-12-18 14:30:41 +00001718 return true;
Douglas Gregore060e572013-01-25 01:03:03 +00001719
Guy Benyei11169dd2012-12-18 14:30:41 +00001720 ASTIdentifierLookupTable *IdTable
1721 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
1722 if (!IdTable)
1723 return false;
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00001724
1725 ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
Richard Smithbdf2d932015-07-30 03:37:16 +00001726 Found);
1727 ++NumIdentifierLookups;
Richard Smith3b637412015-07-14 18:42:41 +00001728 ASTIdentifierLookupTable::iterator Pos =
Richard Smithbdf2d932015-07-30 03:37:16 +00001729 IdTable->find_hashed(Name, NameHash, &Trait);
Guy Benyei11169dd2012-12-18 14:30:41 +00001730 if (Pos == IdTable->end())
1731 return false;
1732
1733 // Dereferencing the iterator has the effect of building the
1734 // IdentifierInfo node and populating it with the various
1735 // declarations it needs.
Richard Smithbdf2d932015-07-30 03:37:16 +00001736 ++NumIdentifierLookupHits;
1737 Found = *Pos;
Guy Benyei11169dd2012-12-18 14:30:41 +00001738 return true;
1739 }
1740
1741 // \brief Retrieve the identifier info found within the module
1742 // files.
1743 IdentifierInfo *getIdentifierInfo() const { return Found; }
1744 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00001745}
Guy Benyei11169dd2012-12-18 14:30:41 +00001746
1747void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
1748 // Note that we are loading an identifier.
1749 Deserializing AnIdentifier(this);
1750
1751 unsigned PriorGeneration = 0;
1752 if (getContext().getLangOpts().Modules)
1753 PriorGeneration = IdentifierGeneration[&II];
Douglas Gregore060e572013-01-25 01:03:03 +00001754
1755 // If there is a global index, look there first to determine which modules
1756 // provably do not have any results for this identifier.
Douglas Gregor7211ac12013-01-25 23:32:03 +00001757 GlobalModuleIndex::HitSet Hits;
Craig Toppera13603a2014-05-22 05:54:18 +00001758 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
Douglas Gregore060e572013-01-25 01:03:03 +00001759 if (!loadGlobalIndex()) {
Douglas Gregor7211ac12013-01-25 23:32:03 +00001760 if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
1761 HitsPtr = &Hits;
Douglas Gregore060e572013-01-25 01:03:03 +00001762 }
1763 }
1764
Douglas Gregor7211ac12013-01-25 23:32:03 +00001765 IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
Douglas Gregor00a50f72013-01-25 00:38:33 +00001766 NumIdentifierLookups,
1767 NumIdentifierLookupHits);
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00001768 ModuleMgr.visit(Visitor, HitsPtr);
Guy Benyei11169dd2012-12-18 14:30:41 +00001769 markIdentifierUpToDate(&II);
1770}
1771
1772void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
1773 if (!II)
1774 return;
1775
1776 II->setOutOfDate(false);
1777
1778 // Update the generation for this identifier.
1779 if (getContext().getLangOpts().Modules)
Richard Smith053f6c62014-05-16 23:01:30 +00001780 IdentifierGeneration[II] = getGeneration();
Guy Benyei11169dd2012-12-18 14:30:41 +00001781}
1782
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001783void ASTReader::resolvePendingMacro(IdentifierInfo *II,
1784 const PendingMacroInfo &PMInfo) {
Richard Smithd7329392015-04-21 21:46:32 +00001785 ModuleFile &M = *PMInfo.M;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001786
1787 BitstreamCursor &Cursor = M.MacroCursor;
1788 SavedStreamPosition SavedPosition(Cursor);
Richard Smithd7329392015-04-21 21:46:32 +00001789 Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001790
Richard Smith713369b2015-04-23 20:40:50 +00001791 struct ModuleMacroRecord {
1792 SubmoduleID SubModID;
1793 MacroInfo *MI;
1794 SmallVector<SubmoduleID, 8> Overrides;
1795 };
1796 llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001797
Richard Smithd7329392015-04-21 21:46:32 +00001798 // We expect to see a sequence of PP_MODULE_MACRO records listing exported
1799 // macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
1800 // macro histroy.
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001801 RecordData Record;
Richard Smithd7329392015-04-21 21:46:32 +00001802 while (true) {
1803 llvm::BitstreamEntry Entry =
1804 Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
1805 if (Entry.Kind != llvm::BitstreamEntry::Record) {
1806 Error("malformed block record in AST file");
1807 return;
1808 }
1809
1810 Record.clear();
Aaron Ballmanc75a1922015-04-22 15:25:05 +00001811 switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
Richard Smithd7329392015-04-21 21:46:32 +00001812 case PP_MACRO_DIRECTIVE_HISTORY:
1813 break;
1814
1815 case PP_MODULE_MACRO: {
Richard Smith713369b2015-04-23 20:40:50 +00001816 ModuleMacros.push_back(ModuleMacroRecord());
1817 auto &Info = ModuleMacros.back();
Richard Smithe56c8bc2015-04-22 00:26:11 +00001818 Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
1819 Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
Richard Smith713369b2015-04-23 20:40:50 +00001820 for (int I = 2, N = Record.size(); I != N; ++I)
1821 Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
Richard Smithd7329392015-04-21 21:46:32 +00001822 continue;
1823 }
1824
1825 default:
1826 Error("malformed block record in AST file");
1827 return;
1828 }
1829
1830 // We found the macro directive history; that's the last record
1831 // for this macro.
1832 break;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001833 }
1834
Richard Smithd7329392015-04-21 21:46:32 +00001835 // Module macros are listed in reverse dependency order.
Richard Smithe56c8bc2015-04-22 00:26:11 +00001836 {
1837 std::reverse(ModuleMacros.begin(), ModuleMacros.end());
Richard Smithe56c8bc2015-04-22 00:26:11 +00001838 llvm::SmallVector<ModuleMacro*, 8> Overrides;
Richard Smith713369b2015-04-23 20:40:50 +00001839 for (auto &MMR : ModuleMacros) {
Richard Smithe56c8bc2015-04-22 00:26:11 +00001840 Overrides.clear();
Richard Smith713369b2015-04-23 20:40:50 +00001841 for (unsigned ModID : MMR.Overrides) {
Richard Smithb8b2ed62015-04-23 18:18:26 +00001842 Module *Mod = getSubmodule(ModID);
1843 auto *Macro = PP.getModuleMacro(Mod, II);
Richard Smithe56c8bc2015-04-22 00:26:11 +00001844 assert(Macro && "missing definition for overridden macro");
Richard Smith5dbef922015-04-22 02:09:43 +00001845 Overrides.push_back(Macro);
Richard Smithe56c8bc2015-04-22 00:26:11 +00001846 }
1847
1848 bool Inserted = false;
Richard Smith713369b2015-04-23 20:40:50 +00001849 Module *Owner = getSubmodule(MMR.SubModID);
Richard Smith20e883e2015-04-29 23:20:19 +00001850 PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
Richard Smithd7329392015-04-21 21:46:32 +00001851 }
1852 }
1853
1854 // Don't read the directive history for a module; we don't have anywhere
1855 // to put it.
1856 if (M.Kind == MK_ImplicitModule || M.Kind == MK_ExplicitModule)
1857 return;
1858
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001859 // Deserialize the macro directives history in reverse source-order.
Craig Toppera13603a2014-05-22 05:54:18 +00001860 MacroDirective *Latest = nullptr, *Earliest = nullptr;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001861 unsigned Idx = 0, N = Record.size();
1862 while (Idx < N) {
Craig Toppera13603a2014-05-22 05:54:18 +00001863 MacroDirective *MD = nullptr;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001864 SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001865 MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
1866 switch (K) {
1867 case MacroDirective::MD_Define: {
Richard Smith713369b2015-04-23 20:40:50 +00001868 MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
Richard Smith3981b172015-04-30 02:16:23 +00001869 MD = PP.AllocateDefMacroDirective(MI, Loc);
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001870 break;
1871 }
Richard Smithdaa69e02014-07-25 04:40:03 +00001872 case MacroDirective::MD_Undefine: {
Richard Smith3981b172015-04-30 02:16:23 +00001873 MD = PP.AllocateUndefMacroDirective(Loc);
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001874 break;
Richard Smithdaa69e02014-07-25 04:40:03 +00001875 }
1876 case MacroDirective::MD_Visibility:
Argyrios Kyrtzidisb6210df2013-03-26 17:17:01 +00001877 bool isPublic = Record[Idx++];
1878 MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
1879 break;
1880 }
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001881
1882 if (!Latest)
1883 Latest = MD;
1884 if (Earliest)
1885 Earliest->setPrevious(MD);
1886 Earliest = MD;
1887 }
1888
Richard Smithd6e8c0d2015-05-04 19:58:00 +00001889 if (Latest)
1890 PP.setLoadedMacroDirective(II, Latest);
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00001891}
1892
Argyrios Kyrtzidisce9b49e2014-03-14 02:26:27 +00001893ASTReader::InputFileInfo
1894ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
Ben Langmuir198c1682014-03-07 07:27:49 +00001895 // Go find this input file.
1896 BitstreamCursor &Cursor = F.InputFilesCursor;
1897 SavedStreamPosition SavedPosition(Cursor);
1898 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1899
1900 unsigned Code = Cursor.ReadCode();
1901 RecordData Record;
1902 StringRef Blob;
1903
1904 unsigned Result = Cursor.readRecord(Code, Record, &Blob);
1905 assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
1906 "invalid record type for input file");
1907 (void)Result;
1908
1909 assert(Record[0] == ID && "Bogus stored ID or offset");
Richard Smitha8cfffa2015-11-26 02:04:16 +00001910 InputFileInfo R;
1911 R.StoredSize = static_cast<off_t>(Record[1]);
1912 R.StoredTime = static_cast<time_t>(Record[2]);
1913 R.Overridden = static_cast<bool>(Record[3]);
1914 R.Transient = static_cast<bool>(Record[4]);
1915 R.Filename = Blob;
1916 ResolveImportedPath(F, R.Filename);
Hans Wennborg73945142014-03-14 17:45:06 +00001917 return R;
Ben Langmuir198c1682014-03-07 07:27:49 +00001918}
1919
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00001920InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
Guy Benyei11169dd2012-12-18 14:30:41 +00001921 // If this ID is bogus, just return an empty input file.
1922 if (ID == 0 || ID > F.InputFilesLoaded.size())
1923 return InputFile();
1924
1925 // If we've already loaded this input file, return it.
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00001926 if (F.InputFilesLoaded[ID-1].getFile())
Guy Benyei11169dd2012-12-18 14:30:41 +00001927 return F.InputFilesLoaded[ID-1];
1928
Argyrios Kyrtzidis9308f0a2014-01-08 19:13:34 +00001929 if (F.InputFilesLoaded[ID-1].isNotFound())
1930 return InputFile();
1931
Guy Benyei11169dd2012-12-18 14:30:41 +00001932 // Go find this input file.
Chris Lattner7fb3bef2013-01-20 00:56:42 +00001933 BitstreamCursor &Cursor = F.InputFilesCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00001934 SavedStreamPosition SavedPosition(Cursor);
1935 Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
1936
Argyrios Kyrtzidisce9b49e2014-03-14 02:26:27 +00001937 InputFileInfo FI = readInputFileInfo(F, ID);
1938 off_t StoredSize = FI.StoredSize;
1939 time_t StoredTime = FI.StoredTime;
1940 bool Overridden = FI.Overridden;
Richard Smitha8cfffa2015-11-26 02:04:16 +00001941 bool Transient = FI.Transient;
Argyrios Kyrtzidisce9b49e2014-03-14 02:26:27 +00001942 StringRef Filename = FI.Filename;
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00001943
Richard Smitha8cfffa2015-11-26 02:04:16 +00001944 const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
Ben Langmuir198c1682014-03-07 07:27:49 +00001945
1946 // If we didn't find the file, resolve it relative to the
1947 // original directory from which this AST file was created.
Craig Toppera13603a2014-05-22 05:54:18 +00001948 if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
Ben Langmuir198c1682014-03-07 07:27:49 +00001949 F.OriginalDir != CurrentDir) {
1950 std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
1951 F.OriginalDir,
1952 CurrentDir);
1953 if (!Resolved.empty())
1954 File = FileMgr.getFile(Resolved);
1955 }
1956
1957 // For an overridden file, create a virtual file with the stored
1958 // size/timestamp.
Richard Smitha8cfffa2015-11-26 02:04:16 +00001959 if ((Overridden || Transient) && File == nullptr)
Ben Langmuir198c1682014-03-07 07:27:49 +00001960 File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
Ben Langmuir198c1682014-03-07 07:27:49 +00001961
Craig Toppera13603a2014-05-22 05:54:18 +00001962 if (File == nullptr) {
Ben Langmuir198c1682014-03-07 07:27:49 +00001963 if (Complain) {
1964 std::string ErrorStr = "could not find file '";
1965 ErrorStr += Filename;
Richard Smith68142212015-10-13 01:26:26 +00001966 ErrorStr += "' referenced by AST file '";
1967 ErrorStr += F.FileName;
1968 ErrorStr += "'";
Ben Langmuir198c1682014-03-07 07:27:49 +00001969 Error(ErrorStr.c_str());
Guy Benyei11169dd2012-12-18 14:30:41 +00001970 }
Ben Langmuir198c1682014-03-07 07:27:49 +00001971 // Record that we didn't find the file.
1972 F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
1973 return InputFile();
1974 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001975
Ben Langmuir198c1682014-03-07 07:27:49 +00001976 // Check if there was a request to override the contents of the file
1977 // that was part of the precompiled header. Overridding such a file
1978 // can lead to problems when lexing using the source locations from the
1979 // PCH.
1980 SourceManager &SM = getSourceManager();
Richard Smith64daf7b2015-12-01 03:32:49 +00001981 // FIXME: Reject if the overrides are different.
1982 if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
Ben Langmuir198c1682014-03-07 07:27:49 +00001983 if (Complain)
1984 Error(diag::err_fe_pch_file_overridden, Filename);
1985 // After emitting the diagnostic, recover by disabling the override so
1986 // that the original file will be used.
Richard Smitha8cfffa2015-11-26 02:04:16 +00001987 //
1988 // FIXME: This recovery is just as broken as the original state; there may
1989 // be another precompiled module that's using the overridden contents, or
1990 // we might be half way through parsing it. Instead, we should treat the
1991 // overridden contents as belonging to a separate FileEntry.
Ben Langmuir198c1682014-03-07 07:27:49 +00001992 SM.disableFileContentsOverride(File);
1993 // The FileEntry is a virtual file entry with the size of the contents
1994 // that would override the original contents. Set it to the original's
1995 // size/time.
1996 FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
1997 StoredSize, StoredTime);
1998 }
Guy Benyei11169dd2012-12-18 14:30:41 +00001999
Ben Langmuir198c1682014-03-07 07:27:49 +00002000 bool IsOutOfDate = false;
2001
2002 // For an overridden file, there is nothing to validate.
Richard Smith96fdab62014-10-28 16:24:08 +00002003 if (!Overridden && //
2004 (StoredSize != File->getSize() ||
2005#if defined(LLVM_ON_WIN32)
2006 false
2007#else
Ben Langmuir198c1682014-03-07 07:27:49 +00002008 // In our regression testing, the Windows file system seems to
2009 // have inconsistent modification times that sometimes
2010 // erroneously trigger this error-handling path.
Richard Smith96fdab62014-10-28 16:24:08 +00002011 //
Richard Smithe75ee0f2015-08-17 07:13:32 +00002012 // FIXME: This probably also breaks HeaderFileInfo lookups on Windows.
2013 (StoredTime && StoredTime != File->getModificationTime() &&
2014 !DisableValidation)
Guy Benyei11169dd2012-12-18 14:30:41 +00002015#endif
Ben Langmuir198c1682014-03-07 07:27:49 +00002016 )) {
2017 if (Complain) {
2018 // Build a list of the PCH imports that got us here (in reverse).
2019 SmallVector<ModuleFile *, 4> ImportStack(1, &F);
2020 while (ImportStack.back()->ImportedBy.size() > 0)
2021 ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
Ben Langmuire82630d2014-01-17 00:19:09 +00002022
Ben Langmuir198c1682014-03-07 07:27:49 +00002023 // The top-level PCH is stale.
2024 StringRef TopLevelPCHName(ImportStack.back()->FileName);
2025 Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
Ben Langmuire82630d2014-01-17 00:19:09 +00002026
Ben Langmuir198c1682014-03-07 07:27:49 +00002027 // Print the import stack.
2028 if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
2029 Diag(diag::note_pch_required_by)
2030 << Filename << ImportStack[0]->FileName;
2031 for (unsigned I = 1; I < ImportStack.size(); ++I)
Ben Langmuire82630d2014-01-17 00:19:09 +00002032 Diag(diag::note_pch_required_by)
Ben Langmuir198c1682014-03-07 07:27:49 +00002033 << ImportStack[I-1]->FileName << ImportStack[I]->FileName;
Douglas Gregor7029ce12013-03-19 00:28:20 +00002034 }
2035
Ben Langmuir198c1682014-03-07 07:27:49 +00002036 if (!Diags.isDiagnosticInFlight())
2037 Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
Guy Benyei11169dd2012-12-18 14:30:41 +00002038 }
2039
Ben Langmuir198c1682014-03-07 07:27:49 +00002040 IsOutOfDate = true;
Guy Benyei11169dd2012-12-18 14:30:41 +00002041 }
Richard Smitha8cfffa2015-11-26 02:04:16 +00002042 // FIXME: If the file is overridden and we've already opened it,
2043 // issue an error (or split it into a separate FileEntry).
Guy Benyei11169dd2012-12-18 14:30:41 +00002044
Richard Smitha8cfffa2015-11-26 02:04:16 +00002045 InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
Ben Langmuir198c1682014-03-07 07:27:49 +00002046
2047 // Note that we've loaded this input file.
2048 F.InputFilesLoaded[ID-1] = IF;
2049 return IF;
Guy Benyei11169dd2012-12-18 14:30:41 +00002050}
2051
Richard Smith7ed1bc92014-12-05 22:42:13 +00002052/// \brief If we are loading a relocatable PCH or module file, and the filename
2053/// is not an absolute path, add the system or module root to the beginning of
2054/// the file name.
2055void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
2056 // Resolve relative to the base directory, if we have one.
2057 if (!M.BaseDirectory.empty())
2058 return ResolveImportedPath(Filename, M.BaseDirectory);
Guy Benyei11169dd2012-12-18 14:30:41 +00002059}
2060
Richard Smith7ed1bc92014-12-05 22:42:13 +00002061void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002062 if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
2063 return;
2064
Richard Smith7ed1bc92014-12-05 22:42:13 +00002065 SmallString<128> Buffer;
2066 llvm::sys::path::append(Buffer, Prefix, Filename);
2067 Filename.assign(Buffer.begin(), Buffer.end());
Guy Benyei11169dd2012-12-18 14:30:41 +00002068}
2069
Richard Smith0f99d6a2015-08-09 08:48:41 +00002070static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
2071 switch (ARR) {
2072 case ASTReader::Failure: return true;
2073 case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
2074 case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
2075 case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
2076 case ASTReader::ConfigurationMismatch:
2077 return !(Caps & ASTReader::ARR_ConfigurationMismatch);
2078 case ASTReader::HadErrors: return true;
2079 case ASTReader::Success: return false;
2080 }
2081
2082 llvm_unreachable("unknown ASTReadResult");
2083}
2084
Richard Smith0516b182015-09-08 19:40:14 +00002085ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
2086 BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
2087 bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
2088 std::string &SuggestedPredefines) {
2089 if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
2090 return Failure;
2091
2092 // Read all of the records in the options block.
2093 RecordData Record;
2094 ASTReadResult Result = Success;
2095 while (1) {
2096 llvm::BitstreamEntry Entry = Stream.advance();
2097
2098 switch (Entry.Kind) {
2099 case llvm::BitstreamEntry::Error:
2100 case llvm::BitstreamEntry::SubBlock:
2101 return Failure;
2102
2103 case llvm::BitstreamEntry::EndBlock:
2104 return Result;
2105
2106 case llvm::BitstreamEntry::Record:
2107 // The interesting case.
2108 break;
2109 }
2110
2111 // Read and process a record.
2112 Record.clear();
2113 switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
2114 case LANGUAGE_OPTIONS: {
2115 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2116 if (ParseLanguageOptions(Record, Complain, Listener,
2117 AllowCompatibleConfigurationMismatch))
2118 Result = ConfigurationMismatch;
2119 break;
2120 }
2121
2122 case TARGET_OPTIONS: {
2123 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2124 if (ParseTargetOptions(Record, Complain, Listener,
2125 AllowCompatibleConfigurationMismatch))
2126 Result = ConfigurationMismatch;
2127 break;
2128 }
2129
2130 case DIAGNOSTIC_OPTIONS: {
2131 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
2132 if (!AllowCompatibleConfigurationMismatch &&
2133 ParseDiagnosticOptions(Record, Complain, Listener))
2134 return OutOfDate;
2135 break;
2136 }
2137
2138 case FILE_SYSTEM_OPTIONS: {
2139 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2140 if (!AllowCompatibleConfigurationMismatch &&
2141 ParseFileSystemOptions(Record, Complain, Listener))
2142 Result = ConfigurationMismatch;
2143 break;
2144 }
2145
2146 case HEADER_SEARCH_OPTIONS: {
2147 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2148 if (!AllowCompatibleConfigurationMismatch &&
2149 ParseHeaderSearchOptions(Record, Complain, Listener))
2150 Result = ConfigurationMismatch;
2151 break;
2152 }
2153
2154 case PREPROCESSOR_OPTIONS:
2155 bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
2156 if (!AllowCompatibleConfigurationMismatch &&
2157 ParsePreprocessorOptions(Record, Complain, Listener,
2158 SuggestedPredefines))
2159 Result = ConfigurationMismatch;
2160 break;
2161 }
2162 }
2163}
2164
Guy Benyei11169dd2012-12-18 14:30:41 +00002165ASTReader::ASTReadResult
2166ASTReader::ReadControlBlock(ModuleFile &F,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002167 SmallVectorImpl<ImportedModule> &Loaded,
Ben Langmuirbeee15e2014-04-14 18:00:01 +00002168 const ModuleFile *ImportedBy,
Guy Benyei11169dd2012-12-18 14:30:41 +00002169 unsigned ClientLoadCapabilities) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00002170 BitstreamCursor &Stream = F.Stream;
Richard Smith8a308ec2015-11-05 00:54:55 +00002171 ASTReadResult Result = Success;
Guy Benyei11169dd2012-12-18 14:30:41 +00002172
2173 if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
2174 Error("malformed block record in AST file");
2175 return Failure;
2176 }
2177
2178 // Read all of the records and blocks in the control block.
2179 RecordData Record;
Richard Smitha1825302014-10-23 22:18:29 +00002180 unsigned NumInputs = 0;
2181 unsigned NumUserInputs = 0;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002182 while (1) {
2183 llvm::BitstreamEntry Entry = Stream.advance();
2184
2185 switch (Entry.Kind) {
2186 case llvm::BitstreamEntry::Error:
2187 Error("malformed block record in AST file");
2188 return Failure;
Dmitri Gribenkof430da42014-02-12 10:33:14 +00002189 case llvm::BitstreamEntry::EndBlock: {
2190 // Validate input files.
2191 const HeaderSearchOptions &HSOpts =
2192 PP.getHeaderSearchInfo().getHeaderSearchOpts();
Ben Langmuircb69b572014-03-07 06:40:32 +00002193
Richard Smitha1825302014-10-23 22:18:29 +00002194 // All user input files reside at the index range [0, NumUserInputs), and
Richard Smith0f99d6a2015-08-09 08:48:41 +00002195 // system input files reside at [NumUserInputs, NumInputs). For explicitly
2196 // loaded module files, ignore missing inputs.
2197 if (!DisableValidation && F.Kind != MK_ExplicitModule) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002198 bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
Ben Langmuircb69b572014-03-07 06:40:32 +00002199
Dmitri Gribenkof430da42014-02-12 10:33:14 +00002200 // If we are reading a module, we will create a verification timestamp,
2201 // so we verify all input files. Otherwise, verify only user input
2202 // files.
Ben Langmuircb69b572014-03-07 06:40:32 +00002203
2204 unsigned N = NumUserInputs;
2205 if (ValidateSystemInputs ||
Richard Smithe842a472014-10-22 02:05:46 +00002206 (HSOpts.ModulesValidateOncePerBuildSession &&
Ben Langmuiracb803e2014-11-10 22:13:10 +00002207 F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
Richard Smithe842a472014-10-22 02:05:46 +00002208 F.Kind == MK_ImplicitModule))
Ben Langmuircb69b572014-03-07 06:40:32 +00002209 N = NumInputs;
2210
Ben Langmuir3d4417c2014-02-07 17:31:11 +00002211 for (unsigned I = 0; I < N; ++I) {
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00002212 InputFile IF = getInputFile(F, I+1, Complain);
2213 if (!IF.getFile() || IF.isOutOfDate())
Guy Benyei11169dd2012-12-18 14:30:41 +00002214 return OutOfDate;
Argyrios Kyrtzidis61c3d872013-03-01 03:26:04 +00002215 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002216 }
Ben Langmuircb69b572014-03-07 06:40:32 +00002217
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +00002218 if (Listener)
Richard Smith216a3bd2015-08-13 17:57:10 +00002219 Listener->visitModuleFile(F.FileName, F.Kind);
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +00002220
Ben Langmuircb69b572014-03-07 06:40:32 +00002221 if (Listener && Listener->needsInputFileVisitation()) {
2222 unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
2223 : NumUserInputs;
Argyrios Kyrtzidis68ccbe02014-03-14 02:26:31 +00002224 for (unsigned I = 0; I < N; ++I) {
2225 bool IsSystem = I >= NumUserInputs;
2226 InputFileInfo FI = readInputFileInfo(F, I+1);
Richard Smith216a3bd2015-08-13 17:57:10 +00002227 Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
2228 F.Kind == MK_ExplicitModule);
Argyrios Kyrtzidis68ccbe02014-03-14 02:26:31 +00002229 }
Ben Langmuircb69b572014-03-07 06:40:32 +00002230 }
2231
Richard Smith8a308ec2015-11-05 00:54:55 +00002232 return Result;
Dmitri Gribenkof430da42014-02-12 10:33:14 +00002233 }
2234
Chris Lattnere7b154b2013-01-19 21:39:22 +00002235 case llvm::BitstreamEntry::SubBlock:
2236 switch (Entry.ID) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002237 case INPUT_FILES_BLOCK_ID:
2238 F.InputFilesCursor = Stream;
2239 if (Stream.SkipBlock() || // Skip with the main cursor
2240 // Read the abbreviations
2241 ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
2242 Error("malformed block record in AST file");
2243 return Failure;
2244 }
2245 continue;
Richard Smith0516b182015-09-08 19:40:14 +00002246
2247 case OPTIONS_BLOCK_ID:
2248 // If we're reading the first module for this group, check its options
2249 // are compatible with ours. For modules it imports, no further checking
2250 // is required, because we checked them when we built it.
2251 if (Listener && !ImportedBy) {
2252 // Should we allow the configuration of the module file to differ from
2253 // the configuration of the current translation unit in a compatible
2254 // way?
2255 //
2256 // FIXME: Allow this for files explicitly specified with -include-pch.
2257 bool AllowCompatibleConfigurationMismatch =
2258 F.Kind == MK_ExplicitModule;
2259
Richard Smith8a308ec2015-11-05 00:54:55 +00002260 Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
2261 AllowCompatibleConfigurationMismatch,
2262 *Listener, SuggestedPredefines);
Richard Smith0516b182015-09-08 19:40:14 +00002263 if (Result == Failure) {
2264 Error("malformed block record in AST file");
2265 return Result;
2266 }
2267
Richard Smith8a308ec2015-11-05 00:54:55 +00002268 if (DisableValidation ||
2269 (AllowConfigurationMismatch && Result == ConfigurationMismatch))
2270 Result = Success;
2271
Ben Langmuir9b1e442e2016-02-11 18:54:02 +00002272 // If we can't load the module, exit early since we likely
2273 // will rebuild the module anyway. The stream may be in the
2274 // middle of a block.
2275 if (Result != Success)
Richard Smith0516b182015-09-08 19:40:14 +00002276 return Result;
2277 } else if (Stream.SkipBlock()) {
2278 Error("malformed block record in AST file");
2279 return Failure;
2280 }
2281 continue;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002282
Guy Benyei11169dd2012-12-18 14:30:41 +00002283 default:
Chris Lattnere7b154b2013-01-19 21:39:22 +00002284 if (Stream.SkipBlock()) {
2285 Error("malformed block record in AST file");
2286 return Failure;
2287 }
2288 continue;
Guy Benyei11169dd2012-12-18 14:30:41 +00002289 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00002290
2291 case llvm::BitstreamEntry::Record:
2292 // The interesting case.
2293 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00002294 }
2295
2296 // Read and process a record.
2297 Record.clear();
Chris Lattner0e6c9402013-01-20 02:38:54 +00002298 StringRef Blob;
2299 switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002300 case METADATA: {
2301 if (Record[0] != VERSION_MAJOR && !DisableValidation) {
2302 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
Dmitri Gribenko2228cd32014-02-11 15:40:09 +00002303 Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
2304 : diag::err_pch_version_too_new);
Guy Benyei11169dd2012-12-18 14:30:41 +00002305 return VersionMismatch;
2306 }
2307
Richard Smithe75ee0f2015-08-17 07:13:32 +00002308 bool hasErrors = Record[6];
Guy Benyei11169dd2012-12-18 14:30:41 +00002309 if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
2310 Diag(diag::err_pch_with_compiler_errors);
2311 return HadErrors;
2312 }
2313
2314 F.RelocatablePCH = Record[4];
Richard Smith7ed1bc92014-12-05 22:42:13 +00002315 // Relative paths in a relocatable PCH are relative to our sysroot.
2316 if (F.RelocatablePCH)
2317 F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
Guy Benyei11169dd2012-12-18 14:30:41 +00002318
Richard Smithe75ee0f2015-08-17 07:13:32 +00002319 F.HasTimestamps = Record[5];
2320
Guy Benyei11169dd2012-12-18 14:30:41 +00002321 const std::string &CurBranch = getClangFullRepositoryVersion();
Chris Lattner0e6c9402013-01-20 02:38:54 +00002322 StringRef ASTBranch = Blob;
Guy Benyei11169dd2012-12-18 14:30:41 +00002323 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
2324 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
Dmitri Gribenko2228cd32014-02-11 15:40:09 +00002325 Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
Guy Benyei11169dd2012-12-18 14:30:41 +00002326 return VersionMismatch;
2327 }
2328 break;
2329 }
2330
Ben Langmuir487ea142014-10-23 18:05:36 +00002331 case SIGNATURE:
2332 assert((!F.Signature || F.Signature == Record[0]) && "signature changed");
2333 F.Signature = Record[0];
2334 break;
2335
Guy Benyei11169dd2012-12-18 14:30:41 +00002336 case IMPORTS: {
2337 // Load each of the imported PCH files.
2338 unsigned Idx = 0, N = Record.size();
2339 while (Idx < N) {
2340 // Read information about the AST file.
2341 ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
2342 // The import location will be the local one for now; we will adjust
2343 // all import locations of module imports after the global source
Richard Smithb22a1d12016-03-27 20:13:24 +00002344 // location info are setup, in ReadAST.
Guy Benyei11169dd2012-12-18 14:30:41 +00002345 SourceLocation ImportLoc =
Richard Smithb22a1d12016-03-27 20:13:24 +00002346 ReadUntranslatedSourceLocation(Record[Idx++]);
Douglas Gregor7029ce12013-03-19 00:28:20 +00002347 off_t StoredSize = (off_t)Record[Idx++];
2348 time_t StoredModTime = (time_t)Record[Idx++];
Ben Langmuir487ea142014-10-23 18:05:36 +00002349 ASTFileSignature StoredSignature = Record[Idx++];
Richard Smith7ed1bc92014-12-05 22:42:13 +00002350 auto ImportedFile = ReadPath(F, Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00002351
Richard Smith0f99d6a2015-08-09 08:48:41 +00002352 // If our client can't cope with us being out of date, we can't cope with
2353 // our dependency being missing.
2354 unsigned Capabilities = ClientLoadCapabilities;
2355 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2356 Capabilities &= ~ARR_Missing;
2357
Guy Benyei11169dd2012-12-18 14:30:41 +00002358 // Load the AST file.
Richard Smith0f99d6a2015-08-09 08:48:41 +00002359 auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
2360 Loaded, StoredSize, StoredModTime,
2361 StoredSignature, Capabilities);
2362
2363 // If we diagnosed a problem, produce a backtrace.
2364 if (isDiagnosedResult(Result, Capabilities))
2365 Diag(diag::note_module_file_imported_by)
2366 << F.FileName << !F.ModuleName.empty() << F.ModuleName;
2367
2368 switch (Result) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002369 case Failure: return Failure;
2370 // If we have to ignore the dependency, we'll have to ignore this too.
Douglas Gregor2f1806e2013-03-19 00:38:50 +00002371 case Missing:
Guy Benyei11169dd2012-12-18 14:30:41 +00002372 case OutOfDate: return OutOfDate;
2373 case VersionMismatch: return VersionMismatch;
2374 case ConfigurationMismatch: return ConfigurationMismatch;
2375 case HadErrors: return HadErrors;
2376 case Success: break;
2377 }
2378 }
2379 break;
2380 }
2381
Guy Benyei11169dd2012-12-18 14:30:41 +00002382 case ORIGINAL_FILE:
2383 F.OriginalSourceFileID = FileID::get(Record[0]);
Chris Lattner0e6c9402013-01-20 02:38:54 +00002384 F.ActualOriginalSourceFileName = Blob;
Guy Benyei11169dd2012-12-18 14:30:41 +00002385 F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
Richard Smith7ed1bc92014-12-05 22:42:13 +00002386 ResolveImportedPath(F, F.OriginalSourceFileName);
Guy Benyei11169dd2012-12-18 14:30:41 +00002387 break;
2388
2389 case ORIGINAL_FILE_ID:
2390 F.OriginalSourceFileID = FileID::get(Record[0]);
2391 break;
2392
2393 case ORIGINAL_PCH_DIR:
Chris Lattner0e6c9402013-01-20 02:38:54 +00002394 F.OriginalDir = Blob;
Guy Benyei11169dd2012-12-18 14:30:41 +00002395 break;
2396
Ben Langmuirbeee15e2014-04-14 18:00:01 +00002397 case MODULE_NAME:
2398 F.ModuleName = Blob;
Ben Langmuir4f5212a2014-04-14 22:12:44 +00002399 if (Listener)
2400 Listener->ReadModuleName(F.ModuleName);
Ben Langmuirbeee15e2014-04-14 18:00:01 +00002401 break;
2402
Richard Smith223d3f22014-12-06 03:21:08 +00002403 case MODULE_DIRECTORY: {
2404 assert(!F.ModuleName.empty() &&
2405 "MODULE_DIRECTORY found before MODULE_NAME");
2406 // If we've already loaded a module map file covering this module, we may
2407 // have a better path for it (relative to the current build).
2408 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
2409 if (M && M->Directory) {
2410 // If we're implicitly loading a module, the base directory can't
2411 // change between the build and use.
2412 if (F.Kind != MK_ExplicitModule) {
2413 const DirectoryEntry *BuildDir =
2414 PP.getFileManager().getDirectory(Blob);
2415 if (!BuildDir || BuildDir != M->Directory) {
2416 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
2417 Diag(diag::err_imported_module_relocated)
2418 << F.ModuleName << Blob << M->Directory->getName();
2419 return OutOfDate;
2420 }
2421 }
2422 F.BaseDirectory = M->Directory->getName();
2423 } else {
2424 F.BaseDirectory = Blob;
2425 }
Richard Smith7ed1bc92014-12-05 22:42:13 +00002426 break;
Richard Smith223d3f22014-12-06 03:21:08 +00002427 }
Richard Smith7ed1bc92014-12-05 22:42:13 +00002428
Ben Langmuirbeee15e2014-04-14 18:00:01 +00002429 case MODULE_MAP_FILE:
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00002430 if (ASTReadResult Result =
2431 ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
2432 return Result;
Ben Langmuir264ea152014-11-08 00:06:39 +00002433 break;
2434
Justin Bognerca9c0cc2015-06-21 20:32:36 +00002435 case INPUT_FILE_OFFSETS:
Richard Smitha1825302014-10-23 22:18:29 +00002436 NumInputs = Record[0];
2437 NumUserInputs = Record[1];
Justin Bogner4c183242015-06-21 20:32:40 +00002438 F.InputFileOffsets =
2439 (const llvm::support::unaligned_uint64_t *)Blob.data();
Richard Smitha1825302014-10-23 22:18:29 +00002440 F.InputFilesLoaded.resize(NumInputs);
Guy Benyei11169dd2012-12-18 14:30:41 +00002441 break;
2442 }
2443 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002444}
2445
Ben Langmuir2c9af442014-04-10 17:57:43 +00002446ASTReader::ASTReadResult
2447ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00002448 BitstreamCursor &Stream = F.Stream;
Guy Benyei11169dd2012-12-18 14:30:41 +00002449
2450 if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
2451 Error("malformed block record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002452 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002453 }
2454
2455 // Read all of the records and blocks for the AST file.
2456 RecordData Record;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002457 while (1) {
2458 llvm::BitstreamEntry Entry = Stream.advance();
2459
2460 switch (Entry.Kind) {
2461 case llvm::BitstreamEntry::Error:
2462 Error("error at end of module block in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002463 return Failure;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002464 case llvm::BitstreamEntry::EndBlock: {
Richard Smithc0fbba72013-04-03 22:49:41 +00002465 // Outside of C++, we do not store a lookup map for the translation unit.
2466 // Instead, mark it as needing a lookup map to be built if this module
2467 // contains any declarations lexically within it (which it always does!).
2468 // This usually has no cost, since we very rarely need the lookup map for
2469 // the translation unit outside C++.
Guy Benyei11169dd2012-12-18 14:30:41 +00002470 DeclContext *DC = Context.getTranslationUnitDecl();
Richard Smithc0fbba72013-04-03 22:49:41 +00002471 if (DC->hasExternalLexicalStorage() &&
2472 !getContext().getLangOpts().CPlusPlus)
Guy Benyei11169dd2012-12-18 14:30:41 +00002473 DC->setMustBuildLookupTable();
Chris Lattnere7b154b2013-01-19 21:39:22 +00002474
Ben Langmuir2c9af442014-04-10 17:57:43 +00002475 return Success;
Guy Benyei11169dd2012-12-18 14:30:41 +00002476 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00002477 case llvm::BitstreamEntry::SubBlock:
2478 switch (Entry.ID) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002479 case DECLTYPES_BLOCK_ID:
2480 // We lazily load the decls block, but we want to set up the
2481 // DeclsCursor cursor to point into it. Clone our current bitcode
2482 // cursor to it, enter the block and read the abbrevs in that block.
2483 // With the main cursor, we just skip over it.
2484 F.DeclsCursor = Stream;
2485 if (Stream.SkipBlock() || // Skip with the main cursor.
2486 // Read the abbrevs.
2487 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
2488 Error("malformed block record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002489 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002490 }
2491 break;
Richard Smithb9eab6d2014-03-20 19:44:17 +00002492
Guy Benyei11169dd2012-12-18 14:30:41 +00002493 case PREPROCESSOR_BLOCK_ID:
2494 F.MacroCursor = Stream;
2495 if (!PP.getExternalSource())
2496 PP.setExternalSource(this);
Chris Lattnere7b154b2013-01-19 21:39:22 +00002497
Guy Benyei11169dd2012-12-18 14:30:41 +00002498 if (Stream.SkipBlock() ||
2499 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
2500 Error("malformed block record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002501 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002502 }
2503 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
2504 break;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002505
Guy Benyei11169dd2012-12-18 14:30:41 +00002506 case PREPROCESSOR_DETAIL_BLOCK_ID:
2507 F.PreprocessorDetailCursor = Stream;
2508 if (Stream.SkipBlock() ||
Chris Lattnere7b154b2013-01-19 21:39:22 +00002509 ReadBlockAbbrevs(F.PreprocessorDetailCursor,
Guy Benyei11169dd2012-12-18 14:30:41 +00002510 PREPROCESSOR_DETAIL_BLOCK_ID)) {
Chris Lattnere7b154b2013-01-19 21:39:22 +00002511 Error("malformed preprocessor detail record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002512 return Failure;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002513 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002514 F.PreprocessorDetailStartOffset
Chris Lattnere7b154b2013-01-19 21:39:22 +00002515 = F.PreprocessorDetailCursor.GetCurrentBitNo();
2516
Guy Benyei11169dd2012-12-18 14:30:41 +00002517 if (!PP.getPreprocessingRecord())
2518 PP.createPreprocessingRecord();
2519 if (!PP.getPreprocessingRecord()->getExternalSource())
2520 PP.getPreprocessingRecord()->SetExternalSource(*this);
2521 break;
2522
2523 case SOURCE_MANAGER_BLOCK_ID:
2524 if (ReadSourceManagerBlock(F))
Ben Langmuir2c9af442014-04-10 17:57:43 +00002525 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002526 break;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002527
Guy Benyei11169dd2012-12-18 14:30:41 +00002528 case SUBMODULE_BLOCK_ID:
Ben Langmuir2c9af442014-04-10 17:57:43 +00002529 if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities))
2530 return Result;
Guy Benyei11169dd2012-12-18 14:30:41 +00002531 break;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002532
Guy Benyei11169dd2012-12-18 14:30:41 +00002533 case COMMENTS_BLOCK_ID: {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00002534 BitstreamCursor C = Stream;
Guy Benyei11169dd2012-12-18 14:30:41 +00002535 if (Stream.SkipBlock() ||
2536 ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
2537 Error("malformed comments block in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002538 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002539 }
2540 CommentsCursors.push_back(std::make_pair(C, &F));
2541 break;
2542 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00002543
Guy Benyei11169dd2012-12-18 14:30:41 +00002544 default:
Chris Lattnere7b154b2013-01-19 21:39:22 +00002545 if (Stream.SkipBlock()) {
2546 Error("malformed block record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002547 return Failure;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002548 }
2549 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00002550 }
2551 continue;
Chris Lattnere7b154b2013-01-19 21:39:22 +00002552
2553 case llvm::BitstreamEntry::Record:
2554 // The interesting case.
2555 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00002556 }
2557
2558 // Read and process a record.
2559 Record.clear();
Chris Lattner0e6c9402013-01-20 02:38:54 +00002560 StringRef Blob;
2561 switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00002562 default: // Default behavior: ignore.
2563 break;
2564
2565 case TYPE_OFFSET: {
2566 if (F.LocalNumTypes != 0) {
2567 Error("duplicate TYPE_OFFSET record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002568 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002569 }
Chris Lattner0e6c9402013-01-20 02:38:54 +00002570 F.TypeOffsets = (const uint32_t *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002571 F.LocalNumTypes = Record[0];
2572 unsigned LocalBaseTypeIndex = Record[1];
2573 F.BaseTypeIndex = getTotalNumTypes();
2574
2575 if (F.LocalNumTypes > 0) {
2576 // Introduce the global -> local mapping for types within this module.
2577 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
2578
2579 // Introduce the local -> global mapping for types within this module.
2580 F.TypeRemap.insertOrReplace(
2581 std::make_pair(LocalBaseTypeIndex,
2582 F.BaseTypeIndex - LocalBaseTypeIndex));
Ben Langmuir52ca6782014-10-20 16:27:32 +00002583
2584 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
Guy Benyei11169dd2012-12-18 14:30:41 +00002585 }
2586 break;
2587 }
2588
2589 case DECL_OFFSET: {
2590 if (F.LocalNumDecls != 0) {
2591 Error("duplicate DECL_OFFSET record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002592 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002593 }
Chris Lattner0e6c9402013-01-20 02:38:54 +00002594 F.DeclOffsets = (const DeclOffset *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002595 F.LocalNumDecls = Record[0];
2596 unsigned LocalBaseDeclID = Record[1];
2597 F.BaseDeclID = getTotalNumDecls();
2598
2599 if (F.LocalNumDecls > 0) {
2600 // Introduce the global -> local mapping for declarations within this
2601 // module.
2602 GlobalDeclMap.insert(
2603 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
2604
2605 // Introduce the local -> global mapping for declarations within this
2606 // module.
2607 F.DeclRemap.insertOrReplace(
2608 std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
2609
2610 // Introduce the global -> local mapping for declarations within this
2611 // module.
2612 F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
Ben Langmuirfe971d92014-08-16 04:54:18 +00002613
Ben Langmuir52ca6782014-10-20 16:27:32 +00002614 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
2615 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002616 break;
2617 }
2618
2619 case TU_UPDATE_LEXICAL: {
2620 DeclContext *TU = Context.getTranslationUnitDecl();
Richard Smith82f8fcd2015-08-06 22:07:25 +00002621 LexicalContents Contents(
2622 reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
2623 Blob.data()),
2624 static_cast<unsigned int>(Blob.size() / 4));
2625 TULexicalDecls.push_back(std::make_pair(&F, Contents));
Guy Benyei11169dd2012-12-18 14:30:41 +00002626 TU->setHasExternalLexicalStorage(true);
2627 break;
2628 }
2629
2630 case UPDATE_VISIBLE: {
2631 unsigned Idx = 0;
2632 serialization::DeclID ID = ReadDeclID(F, Record, Idx);
Richard Smith0f4e2c42015-08-06 04:23:48 +00002633 auto *Data = (const unsigned char*)Blob.data();
Richard Smithd88a7f12015-09-01 20:35:42 +00002634 PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
Richard Smith0f4e2c42015-08-06 04:23:48 +00002635 // If we've already loaded the decl, perform the updates when we finish
2636 // loading this block.
2637 if (Decl *D = GetExistingDecl(ID))
2638 PendingUpdateRecords.push_back(std::make_pair(ID, D));
Guy Benyei11169dd2012-12-18 14:30:41 +00002639 break;
2640 }
2641
2642 case IDENTIFIER_TABLE:
Chris Lattner0e6c9402013-01-20 02:38:54 +00002643 F.IdentifierTableData = Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002644 if (Record[0]) {
Justin Bognerda4e6502014-04-14 16:34:29 +00002645 F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
2646 (const unsigned char *)F.IdentifierTableData + Record[0],
2647 (const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
2648 (const unsigned char *)F.IdentifierTableData,
2649 ASTIdentifierLookupTrait(*this, F));
Guy Benyei11169dd2012-12-18 14:30:41 +00002650
2651 PP.getIdentifierTable().setExternalIdentifierLookup(this);
2652 }
2653 break;
2654
2655 case IDENTIFIER_OFFSET: {
2656 if (F.LocalNumIdentifiers != 0) {
2657 Error("duplicate IDENTIFIER_OFFSET record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002658 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002659 }
Chris Lattner0e6c9402013-01-20 02:38:54 +00002660 F.IdentifierOffsets = (const uint32_t *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002661 F.LocalNumIdentifiers = Record[0];
2662 unsigned LocalBaseIdentifierID = Record[1];
2663 F.BaseIdentifierID = getTotalNumIdentifiers();
2664
2665 if (F.LocalNumIdentifiers > 0) {
2666 // Introduce the global -> local mapping for identifiers within this
2667 // module.
2668 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
2669 &F));
2670
2671 // Introduce the local -> global mapping for identifiers within this
2672 // module.
2673 F.IdentifierRemap.insertOrReplace(
2674 std::make_pair(LocalBaseIdentifierID,
2675 F.BaseIdentifierID - LocalBaseIdentifierID));
Ben Langmuirfe971d92014-08-16 04:54:18 +00002676
Ben Langmuir52ca6782014-10-20 16:27:32 +00002677 IdentifiersLoaded.resize(IdentifiersLoaded.size()
2678 + F.LocalNumIdentifiers);
2679 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002680 break;
2681 }
2682
Richard Smith33e0f7e2015-07-22 02:08:40 +00002683 case INTERESTING_IDENTIFIERS:
2684 F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
2685 break;
2686
Ben Langmuir332aafe2014-01-31 01:06:56 +00002687 case EAGERLY_DESERIALIZED_DECLS:
Richard Smith9e2341d2015-03-23 03:25:59 +00002688 // FIXME: Skip reading this record if our ASTConsumer doesn't care
2689 // about "interesting" decls (for instance, if we're building a module).
Guy Benyei11169dd2012-12-18 14:30:41 +00002690 for (unsigned I = 0, N = Record.size(); I != N; ++I)
Ben Langmuir332aafe2014-01-31 01:06:56 +00002691 EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
Guy Benyei11169dd2012-12-18 14:30:41 +00002692 break;
2693
2694 case SPECIAL_TYPES:
Douglas Gregor44180f82013-02-01 23:45:03 +00002695 if (SpecialTypes.empty()) {
2696 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2697 SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
2698 break;
2699 }
2700
2701 if (SpecialTypes.size() != Record.size()) {
2702 Error("invalid special-types record");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002703 return Failure;
Douglas Gregor44180f82013-02-01 23:45:03 +00002704 }
2705
2706 for (unsigned I = 0, N = Record.size(); I != N; ++I) {
2707 serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
2708 if (!SpecialTypes[I])
2709 SpecialTypes[I] = ID;
2710 // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
2711 // merge step?
2712 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002713 break;
2714
2715 case STATISTICS:
2716 TotalNumStatements += Record[0];
2717 TotalNumMacros += Record[1];
2718 TotalLexicalDeclContexts += Record[2];
2719 TotalVisibleDeclContexts += Record[3];
2720 break;
2721
2722 case UNUSED_FILESCOPED_DECLS:
2723 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2724 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
2725 break;
2726
2727 case DELEGATING_CTORS:
2728 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2729 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
2730 break;
2731
2732 case WEAK_UNDECLARED_IDENTIFIERS:
2733 if (Record.size() % 4 != 0) {
2734 Error("invalid weak identifiers record");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002735 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002736 }
2737
2738 // FIXME: Ignore weak undeclared identifiers from non-original PCH
2739 // files. This isn't the way to do it :)
2740 WeakUndeclaredIdentifiers.clear();
2741
2742 // Translate the weak, undeclared identifiers into global IDs.
2743 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
2744 WeakUndeclaredIdentifiers.push_back(
2745 getGlobalIdentifierID(F, Record[I++]));
2746 WeakUndeclaredIdentifiers.push_back(
2747 getGlobalIdentifierID(F, Record[I++]));
2748 WeakUndeclaredIdentifiers.push_back(
2749 ReadSourceLocation(F, Record, I).getRawEncoding());
2750 WeakUndeclaredIdentifiers.push_back(Record[I++]);
2751 }
2752 break;
2753
Guy Benyei11169dd2012-12-18 14:30:41 +00002754 case SELECTOR_OFFSETS: {
Chris Lattner0e6c9402013-01-20 02:38:54 +00002755 F.SelectorOffsets = (const uint32_t *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002756 F.LocalNumSelectors = Record[0];
2757 unsigned LocalBaseSelectorID = Record[1];
2758 F.BaseSelectorID = getTotalNumSelectors();
2759
2760 if (F.LocalNumSelectors > 0) {
2761 // Introduce the global -> local mapping for selectors within this
2762 // module.
2763 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
2764
2765 // Introduce the local -> global mapping for selectors within this
2766 // module.
2767 F.SelectorRemap.insertOrReplace(
2768 std::make_pair(LocalBaseSelectorID,
2769 F.BaseSelectorID - LocalBaseSelectorID));
Ben Langmuir52ca6782014-10-20 16:27:32 +00002770
2771 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
Guy Benyei11169dd2012-12-18 14:30:41 +00002772 }
2773 break;
2774 }
2775
2776 case METHOD_POOL:
Chris Lattner0e6c9402013-01-20 02:38:54 +00002777 F.SelectorLookupTableData = (const unsigned char *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002778 if (Record[0])
2779 F.SelectorLookupTable
2780 = ASTSelectorLookupTable::Create(
2781 F.SelectorLookupTableData + Record[0],
2782 F.SelectorLookupTableData,
2783 ASTSelectorLookupTrait(*this, F));
2784 TotalNumMethodPoolEntries += Record[1];
2785 break;
2786
2787 case REFERENCED_SELECTOR_POOL:
2788 if (!Record.empty()) {
2789 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
2790 ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
2791 Record[Idx++]));
2792 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
2793 getRawEncoding());
2794 }
2795 }
2796 break;
2797
2798 case PP_COUNTER_VALUE:
2799 if (!Record.empty() && Listener)
2800 Listener->ReadCounter(F, Record[0]);
2801 break;
2802
2803 case FILE_SORTED_DECLS:
Chris Lattner0e6c9402013-01-20 02:38:54 +00002804 F.FileSortedDecls = (const DeclID *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002805 F.NumFileSortedDecls = Record[0];
2806 break;
2807
2808 case SOURCE_LOCATION_OFFSETS: {
Chris Lattner0e6c9402013-01-20 02:38:54 +00002809 F.SLocEntryOffsets = (const uint32_t *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00002810 F.LocalNumSLocEntries = Record[0];
2811 unsigned SLocSpaceSize = Record[1];
Benjamin Kramer867ea1d2014-03-02 13:01:17 +00002812 std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
Ben Langmuir52ca6782014-10-20 16:27:32 +00002813 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
Guy Benyei11169dd2012-12-18 14:30:41 +00002814 SLocSpaceSize);
Richard Smith78d81ec2015-08-12 22:25:24 +00002815 if (!F.SLocEntryBaseID) {
2816 Error("ran out of source locations");
2817 break;
2818 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002819 // Make our entry in the range map. BaseID is negative and growing, so
2820 // we invert it. Because we invert it, though, we need the other end of
2821 // the range.
2822 unsigned RangeStart =
2823 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
2824 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
2825 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
2826
2827 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
2828 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
2829 GlobalSLocOffsetMap.insert(
2830 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
2831 - SLocSpaceSize,&F));
2832
2833 // Initialize the remapping table.
2834 // Invalid stays invalid.
Richard Smithb9eab6d2014-03-20 19:44:17 +00002835 F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
Guy Benyei11169dd2012-12-18 14:30:41 +00002836 // This module. Base was 2 when being compiled.
Richard Smithb9eab6d2014-03-20 19:44:17 +00002837 F.SLocRemap.insertOrReplace(std::make_pair(2U,
Guy Benyei11169dd2012-12-18 14:30:41 +00002838 static_cast<int>(F.SLocEntryBaseOffset - 2)));
2839
2840 TotalNumSLocEntries += F.LocalNumSLocEntries;
2841 break;
2842 }
2843
2844 case MODULE_OFFSET_MAP: {
2845 // Additional remapping information.
Chris Lattner0e6c9402013-01-20 02:38:54 +00002846 const unsigned char *Data = (const unsigned char*)Blob.data();
2847 const unsigned char *DataEnd = Data + Blob.size();
Richard Smithb9eab6d2014-03-20 19:44:17 +00002848
2849 // If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
2850 if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
2851 F.SLocRemap.insert(std::make_pair(0U, 0));
2852 F.SLocRemap.insert(std::make_pair(2U, 1));
2853 }
2854
Guy Benyei11169dd2012-12-18 14:30:41 +00002855 // Continuous range maps we may be updating in our module.
Ben Langmuir785180e2014-10-20 16:27:30 +00002856 typedef ContinuousRangeMap<uint32_t, int, 2>::Builder
2857 RemapBuilder;
2858 RemapBuilder SLocRemap(F.SLocRemap);
2859 RemapBuilder IdentifierRemap(F.IdentifierRemap);
2860 RemapBuilder MacroRemap(F.MacroRemap);
2861 RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
2862 RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
2863 RemapBuilder SelectorRemap(F.SelectorRemap);
2864 RemapBuilder DeclRemap(F.DeclRemap);
2865 RemapBuilder TypeRemap(F.TypeRemap);
Guy Benyei11169dd2012-12-18 14:30:41 +00002866
Richard Smithd8879c82015-08-24 21:59:32 +00002867 while (Data < DataEnd) {
Justin Bogner57ba0b22014-03-28 22:03:24 +00002868 using namespace llvm::support;
2869 uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
Guy Benyei11169dd2012-12-18 14:30:41 +00002870 StringRef Name = StringRef((const char*)Data, Len);
2871 Data += Len;
2872 ModuleFile *OM = ModuleMgr.lookup(Name);
2873 if (!OM) {
2874 Error("SourceLocation remap refers to unknown module");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002875 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002876 }
2877
Justin Bogner57ba0b22014-03-28 22:03:24 +00002878 uint32_t SLocOffset =
2879 endian::readNext<uint32_t, little, unaligned>(Data);
2880 uint32_t IdentifierIDOffset =
2881 endian::readNext<uint32_t, little, unaligned>(Data);
2882 uint32_t MacroIDOffset =
2883 endian::readNext<uint32_t, little, unaligned>(Data);
2884 uint32_t PreprocessedEntityIDOffset =
2885 endian::readNext<uint32_t, little, unaligned>(Data);
2886 uint32_t SubmoduleIDOffset =
2887 endian::readNext<uint32_t, little, unaligned>(Data);
2888 uint32_t SelectorIDOffset =
2889 endian::readNext<uint32_t, little, unaligned>(Data);
2890 uint32_t DeclIDOffset =
2891 endian::readNext<uint32_t, little, unaligned>(Data);
2892 uint32_t TypeIndexOffset =
2893 endian::readNext<uint32_t, little, unaligned>(Data);
2894
Ben Langmuir785180e2014-10-20 16:27:30 +00002895 uint32_t None = std::numeric_limits<uint32_t>::max();
2896
2897 auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
2898 RemapBuilder &Remap) {
2899 if (Offset != None)
2900 Remap.insert(std::make_pair(Offset,
2901 static_cast<int>(BaseOffset - Offset)));
2902 };
2903 mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
2904 mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
2905 mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
2906 mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
2907 PreprocessedEntityRemap);
2908 mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
2909 mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
2910 mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
2911 mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
Guy Benyei11169dd2012-12-18 14:30:41 +00002912
2913 // Global -> local mappings.
2914 F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
2915 }
2916 break;
2917 }
2918
2919 case SOURCE_MANAGER_LINE_TABLE:
2920 if (ParseLineTable(F, Record))
Ben Langmuir2c9af442014-04-10 17:57:43 +00002921 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002922 break;
2923
2924 case SOURCE_LOCATION_PRELOADS: {
2925 // Need to transform from the local view (1-based IDs) to the global view,
2926 // which is based off F.SLocEntryBaseID.
2927 if (!F.PreloadSLocEntries.empty()) {
2928 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002929 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002930 }
2931
2932 F.PreloadSLocEntries.swap(Record);
2933 break;
2934 }
2935
2936 case EXT_VECTOR_DECLS:
2937 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2938 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
2939 break;
2940
2941 case VTABLE_USES:
2942 if (Record.size() % 3 != 0) {
2943 Error("Invalid VTABLE_USES record");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002944 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002945 }
2946
2947 // Later tables overwrite earlier ones.
2948 // FIXME: Modules will have some trouble with this. This is clearly not
2949 // the right way to do this.
2950 VTableUses.clear();
2951
2952 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
2953 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
2954 VTableUses.push_back(
2955 ReadSourceLocation(F, Record, Idx).getRawEncoding());
2956 VTableUses.push_back(Record[Idx++]);
2957 }
2958 break;
2959
Guy Benyei11169dd2012-12-18 14:30:41 +00002960 case PENDING_IMPLICIT_INSTANTIATIONS:
2961 if (PendingInstantiations.size() % 2 != 0) {
2962 Error("Invalid existing PendingInstantiations");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002963 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002964 }
2965
2966 if (Record.size() % 2 != 0) {
2967 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002968 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00002969 }
2970
2971 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
2972 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
2973 PendingInstantiations.push_back(
2974 ReadSourceLocation(F, Record, I).getRawEncoding());
2975 }
2976 break;
2977
2978 case SEMA_DECL_REFS:
Richard Smith3d8e97e2013-10-18 06:54:39 +00002979 if (Record.size() != 2) {
2980 Error("Invalid SEMA_DECL_REFS block");
Ben Langmuir2c9af442014-04-10 17:57:43 +00002981 return Failure;
Richard Smith3d8e97e2013-10-18 06:54:39 +00002982 }
Guy Benyei11169dd2012-12-18 14:30:41 +00002983 for (unsigned I = 0, N = Record.size(); I != N; ++I)
2984 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
2985 break;
2986
2987 case PPD_ENTITIES_OFFSETS: {
Chris Lattner0e6c9402013-01-20 02:38:54 +00002988 F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
2989 assert(Blob.size() % sizeof(PPEntityOffset) == 0);
2990 F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
Guy Benyei11169dd2012-12-18 14:30:41 +00002991
2992 unsigned LocalBasePreprocessedEntityID = Record[0];
2993
2994 unsigned StartingID;
2995 if (!PP.getPreprocessingRecord())
2996 PP.createPreprocessingRecord();
2997 if (!PP.getPreprocessingRecord()->getExternalSource())
2998 PP.getPreprocessingRecord()->SetExternalSource(*this);
2999 StartingID
3000 = PP.getPreprocessingRecord()
Ben Langmuir52ca6782014-10-20 16:27:32 +00003001 ->allocateLoadedEntities(F.NumPreprocessedEntities);
Guy Benyei11169dd2012-12-18 14:30:41 +00003002 F.BasePreprocessedEntityID = StartingID;
3003
3004 if (F.NumPreprocessedEntities > 0) {
3005 // Introduce the global -> local mapping for preprocessed entities in
3006 // this module.
3007 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
3008
3009 // Introduce the local -> global mapping for preprocessed entities in
3010 // this module.
3011 F.PreprocessedEntityRemap.insertOrReplace(
3012 std::make_pair(LocalBasePreprocessedEntityID,
3013 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
3014 }
3015
3016 break;
3017 }
3018
3019 case DECL_UPDATE_OFFSETS: {
3020 if (Record.size() % 2 != 0) {
3021 Error("invalid DECL_UPDATE_OFFSETS block in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00003022 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00003023 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00003024 for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
3025 GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
3026 DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
3027
3028 // If we've already loaded the decl, perform the updates when we finish
3029 // loading this block.
3030 if (Decl *D = GetExistingDecl(ID))
3031 PendingUpdateRecords.push_back(std::make_pair(ID, D));
3032 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003033 break;
3034 }
3035
Guy Benyei11169dd2012-12-18 14:30:41 +00003036 case OBJC_CATEGORIES_MAP: {
3037 if (F.LocalNumObjCCategoriesInMap != 0) {
3038 Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00003039 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00003040 }
3041
3042 F.LocalNumObjCCategoriesInMap = Record[0];
Chris Lattner0e6c9402013-01-20 02:38:54 +00003043 F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00003044 break;
3045 }
3046
3047 case OBJC_CATEGORIES:
3048 F.ObjCCategories.swap(Record);
3049 break;
Richard Smithc2bb8182015-03-24 06:36:48 +00003050
Guy Benyei11169dd2012-12-18 14:30:41 +00003051 case CXX_BASE_SPECIFIER_OFFSETS: {
3052 if (F.LocalNumCXXBaseSpecifiers != 0) {
3053 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00003054 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00003055 }
Richard Smithc2bb8182015-03-24 06:36:48 +00003056
Guy Benyei11169dd2012-12-18 14:30:41 +00003057 F.LocalNumCXXBaseSpecifiers = Record[0];
Chris Lattner0e6c9402013-01-20 02:38:54 +00003058 F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data();
Richard Smithc2bb8182015-03-24 06:36:48 +00003059 break;
3060 }
3061
3062 case CXX_CTOR_INITIALIZERS_OFFSETS: {
3063 if (F.LocalNumCXXCtorInitializers != 0) {
3064 Error("duplicate CXX_CTOR_INITIALIZERS_OFFSETS record in AST file");
3065 return Failure;
3066 }
3067
3068 F.LocalNumCXXCtorInitializers = Record[0];
3069 F.CXXCtorInitializersOffsets = (const uint32_t *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00003070 break;
3071 }
3072
3073 case DIAG_PRAGMA_MAPPINGS:
3074 if (F.PragmaDiagMappings.empty())
3075 F.PragmaDiagMappings.swap(Record);
3076 else
3077 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
3078 Record.begin(), Record.end());
3079 break;
3080
3081 case CUDA_SPECIAL_DECL_REFS:
3082 // Later tables overwrite earlier ones.
3083 // FIXME: Modules will have trouble with this.
3084 CUDASpecialDeclRefs.clear();
3085 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3086 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
3087 break;
3088
3089 case HEADER_SEARCH_TABLE: {
Chris Lattner0e6c9402013-01-20 02:38:54 +00003090 F.HeaderFileInfoTableData = Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00003091 F.LocalNumHeaderFileInfos = Record[1];
Guy Benyei11169dd2012-12-18 14:30:41 +00003092 if (Record[0]) {
3093 F.HeaderFileInfoTable
3094 = HeaderFileInfoLookupTable::Create(
3095 (const unsigned char *)F.HeaderFileInfoTableData + Record[0],
3096 (const unsigned char *)F.HeaderFileInfoTableData,
3097 HeaderFileInfoTrait(*this, F,
3098 &PP.getHeaderSearchInfo(),
Chris Lattner0e6c9402013-01-20 02:38:54 +00003099 Blob.data() + Record[2]));
Guy Benyei11169dd2012-12-18 14:30:41 +00003100
3101 PP.getHeaderSearchInfo().SetExternalSource(this);
3102 if (!PP.getHeaderSearchInfo().getExternalLookup())
3103 PP.getHeaderSearchInfo().SetExternalLookup(this);
3104 }
3105 break;
3106 }
3107
3108 case FP_PRAGMA_OPTIONS:
3109 // Later tables overwrite earlier ones.
3110 FPPragmaOptions.swap(Record);
3111 break;
3112
3113 case OPENCL_EXTENSIONS:
3114 // Later tables overwrite earlier ones.
3115 OpenCLExtensions.swap(Record);
3116 break;
3117
3118 case TENTATIVE_DEFINITIONS:
3119 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3120 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
3121 break;
3122
3123 case KNOWN_NAMESPACES:
3124 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3125 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
3126 break;
Nick Lewycky8334af82013-01-26 00:35:08 +00003127
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00003128 case UNDEFINED_BUT_USED:
3129 if (UndefinedButUsed.size() % 2 != 0) {
3130 Error("Invalid existing UndefinedButUsed");
Ben Langmuir2c9af442014-04-10 17:57:43 +00003131 return Failure;
Nick Lewycky8334af82013-01-26 00:35:08 +00003132 }
3133
3134 if (Record.size() % 2 != 0) {
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00003135 Error("invalid undefined-but-used record");
Ben Langmuir2c9af442014-04-10 17:57:43 +00003136 return Failure;
Nick Lewycky8334af82013-01-26 00:35:08 +00003137 }
3138 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00003139 UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
3140 UndefinedButUsed.push_back(
Nick Lewycky8334af82013-01-26 00:35:08 +00003141 ReadSourceLocation(F, Record, I).getRawEncoding());
3142 }
3143 break;
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00003144 case DELETE_EXPRS_TO_ANALYZE:
3145 for (unsigned I = 0, N = Record.size(); I != N;) {
3146 DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
3147 const uint64_t Count = Record[I++];
3148 DelayedDeleteExprs.push_back(Count);
3149 for (uint64_t C = 0; C < Count; ++C) {
3150 DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
3151 bool IsArrayForm = Record[I++] == 1;
3152 DelayedDeleteExprs.push_back(IsArrayForm);
3153 }
3154 }
3155 break;
Nick Lewycky8334af82013-01-26 00:35:08 +00003156
Guy Benyei11169dd2012-12-18 14:30:41 +00003157 case IMPORTED_MODULES: {
Richard Smithe842a472014-10-22 02:05:46 +00003158 if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003159 // If we aren't loading a module (which has its own exports), make
3160 // all of the imported modules visible.
3161 // FIXME: Deal with macros-only imports.
Richard Smith56be7542014-03-21 00:33:59 +00003162 for (unsigned I = 0, N = Record.size(); I != N; /**/) {
3163 unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
3164 SourceLocation Loc = ReadSourceLocation(F, Record, I);
3165 if (GlobalID)
Aaron Ballman4f45b712014-03-21 15:22:56 +00003166 ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
Guy Benyei11169dd2012-12-18 14:30:41 +00003167 }
3168 }
3169 break;
3170 }
3171
Guy Benyei11169dd2012-12-18 14:30:41 +00003172 case MACRO_OFFSET: {
3173 if (F.LocalNumMacros != 0) {
3174 Error("duplicate MACRO_OFFSET record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00003175 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00003176 }
Chris Lattner0e6c9402013-01-20 02:38:54 +00003177 F.MacroOffsets = (const uint32_t *)Blob.data();
Guy Benyei11169dd2012-12-18 14:30:41 +00003178 F.LocalNumMacros = Record[0];
3179 unsigned LocalBaseMacroID = Record[1];
3180 F.BaseMacroID = getTotalNumMacros();
3181
3182 if (F.LocalNumMacros > 0) {
3183 // Introduce the global -> local mapping for macros within this module.
3184 GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
3185
3186 // Introduce the local -> global mapping for macros within this module.
3187 F.MacroRemap.insertOrReplace(
3188 std::make_pair(LocalBaseMacroID,
3189 F.BaseMacroID - LocalBaseMacroID));
Ben Langmuir52ca6782014-10-20 16:27:32 +00003190
3191 MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
Guy Benyei11169dd2012-12-18 14:30:41 +00003192 }
3193 break;
3194 }
3195
Richard Smithe40f2ba2013-08-07 21:41:30 +00003196 case LATE_PARSED_TEMPLATE: {
3197 LateParsedTemplates.append(Record.begin(), Record.end());
3198 break;
3199 }
Dario Domizioli13a0a382014-05-23 12:13:25 +00003200
3201 case OPTIMIZE_PRAGMA_OPTIONS:
3202 if (Record.size() != 1) {
3203 Error("invalid pragma optimize record");
3204 return Failure;
3205 }
3206 OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
3207 break;
Nico Weber72889432014-09-06 01:25:55 +00003208
Nico Weber779355f2016-03-02 23:22:00 +00003209 case MSSTRUCT_PRAGMA_OPTIONS:
3210 if (Record.size() != 1) {
3211 Error("invalid pragma ms_struct record");
3212 return Failure;
3213 }
3214 PragmaMSStructState = Record[0];
3215 break;
3216
Nico Weber42932312016-03-03 00:17:35 +00003217 case POINTERS_TO_MEMBERS_PRAGMA_OPTIONS:
3218 if (Record.size() != 2) {
3219 Error("invalid pragma ms_struct record");
3220 return Failure;
3221 }
3222 PragmaMSPointersToMembersState = Record[0];
3223 PointersToMembersPragmaLocation = ReadSourceLocation(F, Record[1]);
3224 break;
3225
Nico Weber72889432014-09-06 01:25:55 +00003226 case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
3227 for (unsigned I = 0, N = Record.size(); I != N; ++I)
3228 UnusedLocalTypedefNameCandidates.push_back(
3229 getGlobalDeclID(F, Record[I]));
3230 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00003231 }
3232 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003233}
3234
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003235ASTReader::ASTReadResult
3236ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
3237 const ModuleFile *ImportedBy,
3238 unsigned ClientLoadCapabilities) {
3239 unsigned Idx = 0;
Richard Smith7ed1bc92014-12-05 22:42:13 +00003240 F.ModuleMapPath = ReadPath(F, Record, Idx);
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003241
Richard Smithe842a472014-10-22 02:05:46 +00003242 if (F.Kind == MK_ExplicitModule) {
3243 // For an explicitly-loaded module, we don't care whether the original
3244 // module map file exists or matches.
3245 return Success;
3246 }
3247
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003248 // Try to resolve ModuleName in the current header search context and
3249 // verify that it is found in the same module map file as we saved. If the
3250 // top-level AST file is a main file, skip this check because there is no
3251 // usable header search context.
3252 assert(!F.ModuleName.empty() &&
Richard Smithe842a472014-10-22 02:05:46 +00003253 "MODULE_NAME should come before MODULE_MAP_FILE");
3254 if (F.Kind == MK_ImplicitModule &&
3255 (*ModuleMgr.begin())->Kind != MK_MainFile) {
3256 // An implicitly-loaded module file should have its module listed in some
3257 // module map file that we've already loaded.
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003258 Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
Richard Smithe842a472014-10-22 02:05:46 +00003259 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
3260 const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
3261 if (!ModMap) {
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003262 assert(ImportedBy && "top-level import should be verified");
Richard Smith0f99d6a2015-08-09 08:48:41 +00003263 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
3264 if (auto *ASTFE = M ? M->getASTFile() : nullptr)
3265 // This module was defined by an imported (explicit) module.
3266 Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
3267 << ASTFE->getName();
3268 else
3269 // This module was built with a different module map.
3270 Diag(diag::err_imported_module_not_found)
3271 << F.ModuleName << F.FileName << ImportedBy->FileName
3272 << F.ModuleMapPath;
3273 }
3274 return OutOfDate;
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003275 }
3276
Richard Smithe842a472014-10-22 02:05:46 +00003277 assert(M->Name == F.ModuleName && "found module with different name");
3278
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003279 // Check the primary module map file.
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003280 const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003281 if (StoredModMap == nullptr || StoredModMap != ModMap) {
3282 assert(ModMap && "found module is missing module map file");
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003283 assert(ImportedBy && "top-level import should be verified");
3284 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3285 Diag(diag::err_imported_module_modmap_changed)
3286 << F.ModuleName << ImportedBy->FileName
3287 << ModMap->getName() << F.ModuleMapPath;
3288 return OutOfDate;
3289 }
3290
3291 llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
3292 for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
3293 // FIXME: we should use input files rather than storing names.
Richard Smith7ed1bc92014-12-05 22:42:13 +00003294 std::string Filename = ReadPath(F, Record, Idx);
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00003295 const FileEntry *F =
3296 FileMgr.getFile(Filename, false, false);
3297 if (F == nullptr) {
3298 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3299 Error("could not find file '" + Filename +"' referenced by AST file");
3300 return OutOfDate;
3301 }
3302 AdditionalStoredMaps.insert(F);
3303 }
3304
3305 // Check any additional module map files (e.g. module.private.modulemap)
3306 // that are not in the pcm.
3307 if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
3308 for (const FileEntry *ModMap : *AdditionalModuleMaps) {
3309 // Remove files that match
3310 // Note: SmallPtrSet::erase is really remove
3311 if (!AdditionalStoredMaps.erase(ModMap)) {
3312 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3313 Diag(diag::err_module_different_modmap)
3314 << F.ModuleName << /*new*/0 << ModMap->getName();
3315 return OutOfDate;
3316 }
3317 }
3318 }
3319
3320 // Check any additional module map files that are in the pcm, but not
3321 // found in header search. Cases that match are already removed.
3322 for (const FileEntry *ModMap : AdditionalStoredMaps) {
3323 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
3324 Diag(diag::err_module_different_modmap)
3325 << F.ModuleName << /*not new*/1 << ModMap->getName();
3326 return OutOfDate;
3327 }
3328 }
3329
3330 if (Listener)
3331 Listener->ReadModuleMapFile(F.ModuleMapPath);
3332 return Success;
3333}
3334
3335
Douglas Gregorc1489562013-02-12 23:36:21 +00003336/// \brief Move the given method to the back of the global list of methods.
3337static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
3338 // Find the entry for this selector in the method pool.
3339 Sema::GlobalMethodPool::iterator Known
3340 = S.MethodPool.find(Method->getSelector());
3341 if (Known == S.MethodPool.end())
3342 return;
3343
3344 // Retrieve the appropriate method list.
3345 ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
3346 : Known->second.second;
3347 bool Found = false;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00003348 for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
Douglas Gregorc1489562013-02-12 23:36:21 +00003349 if (!Found) {
Nico Weber2e0c8f72014-12-27 03:58:08 +00003350 if (List->getMethod() == Method) {
Douglas Gregorc1489562013-02-12 23:36:21 +00003351 Found = true;
3352 } else {
3353 // Keep searching.
3354 continue;
3355 }
3356 }
3357
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00003358 if (List->getNext())
Nico Weber2e0c8f72014-12-27 03:58:08 +00003359 List->setMethod(List->getNext()->getMethod());
Douglas Gregorc1489562013-02-12 23:36:21 +00003360 else
Nico Weber2e0c8f72014-12-27 03:58:08 +00003361 List->setMethod(Method);
Douglas Gregorc1489562013-02-12 23:36:21 +00003362 }
3363}
3364
Richard Smithde711422015-04-23 21:20:19 +00003365void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
Richard Smith10434f32015-05-02 02:08:26 +00003366 assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
Richard Smith20e883e2015-04-29 23:20:19 +00003367 for (Decl *D : Names) {
Richard Smith49f906a2014-03-01 00:08:04 +00003368 bool wasHidden = D->Hidden;
3369 D->Hidden = false;
Guy Benyei11169dd2012-12-18 14:30:41 +00003370
Richard Smith49f906a2014-03-01 00:08:04 +00003371 if (wasHidden && SemaObj) {
3372 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
3373 moveMethodToBackOfGlobalList(*SemaObj, Method);
Douglas Gregorc1489562013-02-12 23:36:21 +00003374 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003375 }
3376 }
3377}
3378
Richard Smith49f906a2014-03-01 00:08:04 +00003379void ASTReader::makeModuleVisible(Module *Mod,
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00003380 Module::NameVisibilityKind NameVisibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +00003381 SourceLocation ImportLoc) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003382 llvm::SmallPtrSet<Module *, 4> Visited;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003383 SmallVector<Module *, 4> Stack;
Robert Wilhelm25284cc2013-08-23 16:11:15 +00003384 Stack.push_back(Mod);
Guy Benyei11169dd2012-12-18 14:30:41 +00003385 while (!Stack.empty()) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +00003386 Mod = Stack.pop_back_val();
Guy Benyei11169dd2012-12-18 14:30:41 +00003387
3388 if (NameVisibility <= Mod->NameVisibility) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +00003389 // This module already has this level of visibility (or greater), so
Guy Benyei11169dd2012-12-18 14:30:41 +00003390 // there is nothing more to do.
3391 continue;
3392 }
Richard Smith49f906a2014-03-01 00:08:04 +00003393
Guy Benyei11169dd2012-12-18 14:30:41 +00003394 if (!Mod->isAvailable()) {
3395 // Modules that aren't available cannot be made visible.
3396 continue;
3397 }
3398
3399 // Update the module's name visibility.
3400 Mod->NameVisibility = NameVisibility;
Richard Smith49f906a2014-03-01 00:08:04 +00003401
Guy Benyei11169dd2012-12-18 14:30:41 +00003402 // If we've already deserialized any names from this module,
3403 // mark them as visible.
3404 HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
3405 if (Hidden != HiddenNamesMap.end()) {
Richard Smith57721ac2014-07-21 04:10:40 +00003406 auto HiddenNames = std::move(*Hidden);
Guy Benyei11169dd2012-12-18 14:30:41 +00003407 HiddenNamesMap.erase(Hidden);
Richard Smithde711422015-04-23 21:20:19 +00003408 makeNamesVisible(HiddenNames.second, HiddenNames.first);
Richard Smith57721ac2014-07-21 04:10:40 +00003409 assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
3410 "making names visible added hidden names");
Guy Benyei11169dd2012-12-18 14:30:41 +00003411 }
Dmitri Gribenkoe9bcf5b2013-11-04 21:51:33 +00003412
Guy Benyei11169dd2012-12-18 14:30:41 +00003413 // Push any exported modules onto the stack to be marked as visible.
Argyrios Kyrtzidis8739f7b2013-02-19 19:34:40 +00003414 SmallVector<Module *, 16> Exports;
3415 Mod->getExportedModules(Exports);
3416 for (SmallVectorImpl<Module *>::iterator
3417 I = Exports.begin(), E = Exports.end(); I != E; ++I) {
3418 Module *Exported = *I;
David Blaikie82e95a32014-11-19 07:49:47 +00003419 if (Visited.insert(Exported).second)
Argyrios Kyrtzidis8739f7b2013-02-19 19:34:40 +00003420 Stack.push_back(Exported);
Guy Benyei11169dd2012-12-18 14:30:41 +00003421 }
3422 }
3423}
3424
Douglas Gregore060e572013-01-25 01:03:03 +00003425bool ASTReader::loadGlobalIndex() {
3426 if (GlobalIndex)
3427 return false;
3428
3429 if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
3430 !Context.getLangOpts().Modules)
3431 return true;
3432
3433 // Try to load the global index.
3434 TriedLoadingGlobalIndex = true;
3435 StringRef ModuleCachePath
3436 = getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
3437 std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
Douglas Gregor7029ce12013-03-19 00:28:20 +00003438 = GlobalModuleIndex::readIndex(ModuleCachePath);
Douglas Gregore060e572013-01-25 01:03:03 +00003439 if (!Result.first)
3440 return true;
3441
3442 GlobalIndex.reset(Result.first);
Douglas Gregor7211ac12013-01-25 23:32:03 +00003443 ModuleMgr.setGlobalIndex(GlobalIndex.get());
Douglas Gregore060e572013-01-25 01:03:03 +00003444 return false;
3445}
3446
3447bool ASTReader::isGlobalIndexUnavailable() const {
3448 return Context.getLangOpts().Modules && UseGlobalIndex &&
3449 !hasGlobalIndex() && TriedLoadingGlobalIndex;
3450}
3451
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003452static void updateModuleTimestamp(ModuleFile &MF) {
3453 // Overwrite the timestamp file contents so that file's mtime changes.
3454 std::string TimestampFilename = MF.getTimestampFilename();
Rafael Espindoladae941a2014-08-25 18:17:04 +00003455 std::error_code EC;
3456 llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
3457 if (EC)
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003458 return;
3459 OS << "Timestamp file\n";
3460}
3461
Douglas Gregor6623e1f2015-11-03 18:33:07 +00003462/// \brief Given a cursor at the start of an AST file, scan ahead and drop the
3463/// cursor into the start of the given block ID, returning false on success and
3464/// true on failure.
3465static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
3466 while (1) {
3467 llvm::BitstreamEntry Entry = Cursor.advance();
3468 switch (Entry.Kind) {
3469 case llvm::BitstreamEntry::Error:
3470 case llvm::BitstreamEntry::EndBlock:
3471 return true;
3472
3473 case llvm::BitstreamEntry::Record:
3474 // Ignore top-level records.
3475 Cursor.skipRecord(Entry.ID);
3476 break;
3477
3478 case llvm::BitstreamEntry::SubBlock:
3479 if (Entry.ID == BlockID) {
3480 if (Cursor.EnterSubBlock(BlockID))
3481 return true;
3482 // Found it!
3483 return false;
3484 }
3485
3486 if (Cursor.SkipBlock())
3487 return true;
3488 }
3489 }
3490}
3491
Benjamin Kramer0772c422016-02-13 13:42:54 +00003492ASTReader::ASTReadResult ASTReader::ReadAST(StringRef FileName,
Guy Benyei11169dd2012-12-18 14:30:41 +00003493 ModuleKind Type,
3494 SourceLocation ImportLoc,
3495 unsigned ClientLoadCapabilities) {
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00003496 llvm::SaveAndRestore<SourceLocation>
3497 SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
3498
Richard Smithd1c46742014-04-30 02:24:17 +00003499 // Defer any pending actions until we get to the end of reading the AST file.
3500 Deserializing AnASTFile(this);
3501
Guy Benyei11169dd2012-12-18 14:30:41 +00003502 // Bump the generation number.
Richard Smith053f6c62014-05-16 23:01:30 +00003503 unsigned PreviousGeneration = incrementGeneration(Context);
Guy Benyei11169dd2012-12-18 14:30:41 +00003504
3505 unsigned NumModules = ModuleMgr.size();
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003506 SmallVector<ImportedModule, 4> Loaded;
Guy Benyei11169dd2012-12-18 14:30:41 +00003507 switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
Craig Toppera13603a2014-05-22 05:54:18 +00003508 /*ImportedBy=*/nullptr, Loaded,
Ben Langmuir487ea142014-10-23 18:05:36 +00003509 0, 0, 0,
Guy Benyei11169dd2012-12-18 14:30:41 +00003510 ClientLoadCapabilities)) {
3511 case Failure:
Douglas Gregor7029ce12013-03-19 00:28:20 +00003512 case Missing:
Guy Benyei11169dd2012-12-18 14:30:41 +00003513 case OutOfDate:
3514 case VersionMismatch:
3515 case ConfigurationMismatch:
Ben Langmuir9801b252014-06-20 00:24:56 +00003516 case HadErrors: {
3517 llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
3518 for (const ImportedModule &IM : Loaded)
3519 LoadedSet.insert(IM.Mod);
3520
Douglas Gregor7029ce12013-03-19 00:28:20 +00003521 ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
Ben Langmuir9801b252014-06-20 00:24:56 +00003522 LoadedSet,
Douglas Gregor7029ce12013-03-19 00:28:20 +00003523 Context.getLangOpts().Modules
3524 ? &PP.getHeaderSearchInfo().getModuleMap()
Craig Toppera13603a2014-05-22 05:54:18 +00003525 : nullptr);
Douglas Gregore060e572013-01-25 01:03:03 +00003526
3527 // If we find that any modules are unusable, the global index is going
3528 // to be out-of-date. Just remove it.
3529 GlobalIndex.reset();
Craig Toppera13603a2014-05-22 05:54:18 +00003530 ModuleMgr.setGlobalIndex(nullptr);
Guy Benyei11169dd2012-12-18 14:30:41 +00003531 return ReadResult;
Ben Langmuir9801b252014-06-20 00:24:56 +00003532 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003533 case Success:
3534 break;
3535 }
3536
3537 // Here comes stuff that we only do once the entire chain is loaded.
3538
3539 // Load the AST blocks of all of the modules that we loaded.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003540 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3541 MEnd = Loaded.end();
Guy Benyei11169dd2012-12-18 14:30:41 +00003542 M != MEnd; ++M) {
3543 ModuleFile &F = *M->Mod;
3544
3545 // Read the AST block.
Ben Langmuir2c9af442014-04-10 17:57:43 +00003546 if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
3547 return Result;
Guy Benyei11169dd2012-12-18 14:30:41 +00003548
Douglas Gregor6623e1f2015-11-03 18:33:07 +00003549 // Read the extension blocks.
3550 while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
3551 if (ASTReadResult Result = ReadExtensionBlock(F))
3552 return Result;
3553 }
3554
Guy Benyei11169dd2012-12-18 14:30:41 +00003555 // Once read, set the ModuleFile bit base offset and update the size in
3556 // bits of all files we've seen.
3557 F.GlobalBitOffset = TotalModulesSizeInBits;
3558 TotalModulesSizeInBits += F.SizeInBits;
3559 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
3560
3561 // Preload SLocEntries.
3562 for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
3563 int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
3564 // Load it through the SourceManager and don't call ReadSLocEntry()
3565 // directly because the entry may have already been loaded in which case
3566 // calling ReadSLocEntry() directly would trigger an assertion in
3567 // SourceManager.
3568 SourceMgr.getLoadedSLocEntryByID(Index);
3569 }
Richard Smith33e0f7e2015-07-22 02:08:40 +00003570
3571 // Preload all the pending interesting identifiers by marking them out of
3572 // date.
3573 for (auto Offset : F.PreloadIdentifierOffsets) {
3574 const unsigned char *Data = reinterpret_cast<const unsigned char *>(
3575 F.IdentifierTableData + Offset);
3576
3577 ASTIdentifierLookupTrait Trait(*this, F);
3578 auto KeyDataLen = Trait.ReadKeyDataLength(Data);
3579 auto Key = Trait.ReadKey(Data, KeyDataLen.first);
Richard Smith79bf9202015-08-24 03:33:22 +00003580 auto &II = PP.getIdentifierTable().getOwn(Key);
3581 II.setOutOfDate(true);
3582
3583 // Mark this identifier as being from an AST file so that we can track
3584 // whether we need to serialize it.
Richard Smitheb4b58f62016-02-05 01:40:54 +00003585 markIdentifierFromAST(*this, II);
Richard Smith79bf9202015-08-24 03:33:22 +00003586
3587 // Associate the ID with the identifier so that the writer can reuse it.
3588 auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
3589 SetIdentifierInfo(ID, &II);
Richard Smith33e0f7e2015-07-22 02:08:40 +00003590 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003591 }
3592
Douglas Gregor603cd862013-03-22 18:50:14 +00003593 // Setup the import locations and notify the module manager that we've
3594 // committed to these module files.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003595 for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
3596 MEnd = Loaded.end();
Guy Benyei11169dd2012-12-18 14:30:41 +00003597 M != MEnd; ++M) {
3598 ModuleFile &F = *M->Mod;
Douglas Gregor603cd862013-03-22 18:50:14 +00003599
3600 ModuleMgr.moduleFileAccepted(&F);
3601
3602 // Set the import location.
Argyrios Kyrtzidis71c1af82013-02-01 16:36:14 +00003603 F.DirectImportLoc = ImportLoc;
Richard Smithb22a1d12016-03-27 20:13:24 +00003604 // FIXME: We assume that locations from PCH / preamble do not need
3605 // any translation.
Guy Benyei11169dd2012-12-18 14:30:41 +00003606 if (!M->ImportedBy)
3607 F.ImportLoc = M->ImportLoc;
3608 else
Richard Smithb22a1d12016-03-27 20:13:24 +00003609 F.ImportLoc = TranslateSourceLocation(*M->ImportedBy, M->ImportLoc);
Guy Benyei11169dd2012-12-18 14:30:41 +00003610 }
3611
Richard Smith33e0f7e2015-07-22 02:08:40 +00003612 if (!Context.getLangOpts().CPlusPlus ||
3613 (Type != MK_ImplicitModule && Type != MK_ExplicitModule)) {
3614 // Mark all of the identifiers in the identifier table as being out of date,
3615 // so that various accessors know to check the loaded modules when the
3616 // identifier is used.
3617 //
3618 // For C++ modules, we don't need information on many identifiers (just
3619 // those that provide macros or are poisoned), so we mark all of
3620 // the interesting ones via PreloadIdentifierOffsets.
3621 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
3622 IdEnd = PP.getIdentifierTable().end();
3623 Id != IdEnd; ++Id)
3624 Id->second->setOutOfDate(true);
3625 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003626
3627 // Resolve any unresolved module exports.
Douglas Gregorfb912652013-03-20 21:10:35 +00003628 for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
3629 UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
Guy Benyei11169dd2012-12-18 14:30:41 +00003630 SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
3631 Module *ResolvedMod = getSubmodule(GlobalID);
Douglas Gregorfb912652013-03-20 21:10:35 +00003632
3633 switch (Unresolved.Kind) {
3634 case UnresolvedModuleRef::Conflict:
3635 if (ResolvedMod) {
3636 Module::Conflict Conflict;
3637 Conflict.Other = ResolvedMod;
3638 Conflict.Message = Unresolved.String.str();
3639 Unresolved.Mod->Conflicts.push_back(Conflict);
3640 }
3641 continue;
3642
3643 case UnresolvedModuleRef::Import:
Guy Benyei11169dd2012-12-18 14:30:41 +00003644 if (ResolvedMod)
Richard Smith38477db2015-05-02 00:45:56 +00003645 Unresolved.Mod->Imports.insert(ResolvedMod);
Guy Benyei11169dd2012-12-18 14:30:41 +00003646 continue;
Guy Benyei11169dd2012-12-18 14:30:41 +00003647
Douglas Gregorfb912652013-03-20 21:10:35 +00003648 case UnresolvedModuleRef::Export:
3649 if (ResolvedMod || Unresolved.IsWildcard)
3650 Unresolved.Mod->Exports.push_back(
3651 Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
3652 continue;
3653 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003654 }
Douglas Gregorfb912652013-03-20 21:10:35 +00003655 UnresolvedModuleRefs.clear();
Daniel Jasperba7f2f72013-09-24 09:14:14 +00003656
3657 // FIXME: How do we load the 'use'd modules? They may not be submodules.
3658 // Might be unnecessary as use declarations are only used to build the
3659 // module itself.
Guy Benyei11169dd2012-12-18 14:30:41 +00003660
3661 InitializeContext();
3662
Richard Smith3d8e97e2013-10-18 06:54:39 +00003663 if (SemaObj)
3664 UpdateSema();
3665
Guy Benyei11169dd2012-12-18 14:30:41 +00003666 if (DeserializationListener)
3667 DeserializationListener->ReaderInitialized(this);
3668
3669 ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
Yaron Keren8b563662015-10-03 10:46:20 +00003670 if (PrimaryModule.OriginalSourceFileID.isValid()) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003671 PrimaryModule.OriginalSourceFileID
3672 = FileID::get(PrimaryModule.SLocEntryBaseID
3673 + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
3674
3675 // If this AST file is a precompiled preamble, then set the
3676 // preamble file ID of the source manager to the file source file
3677 // from which the preamble was built.
3678 if (Type == MK_Preamble) {
3679 SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
3680 } else if (Type == MK_MainFile) {
3681 SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
3682 }
3683 }
3684
3685 // For any Objective-C class definitions we have already loaded, make sure
3686 // that we load any additional categories.
3687 for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
3688 loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
3689 ObjCClassesLoaded[I],
3690 PreviousGeneration);
3691 }
Douglas Gregore060e572013-01-25 01:03:03 +00003692
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003693 if (PP.getHeaderSearchInfo()
3694 .getHeaderSearchOpts()
3695 .ModulesValidateOncePerBuildSession) {
3696 // Now we are certain that the module and all modules it depends on are
3697 // up to date. Create or update timestamp files for modules that are
3698 // located in the module cache (not for PCH files that could be anywhere
3699 // in the filesystem).
3700 for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
3701 ImportedModule &M = Loaded[I];
Richard Smithe842a472014-10-22 02:05:46 +00003702 if (M.Mod->Kind == MK_ImplicitModule) {
Dmitri Gribenkof430da42014-02-12 10:33:14 +00003703 updateModuleTimestamp(*M.Mod);
3704 }
3705 }
3706 }
3707
Guy Benyei11169dd2012-12-18 14:30:41 +00003708 return Success;
3709}
3710
Ben Langmuir487ea142014-10-23 18:05:36 +00003711static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile);
3712
Ben Langmuir70a1b812015-03-24 04:43:52 +00003713/// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
3714static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
3715 return Stream.Read(8) == 'C' &&
3716 Stream.Read(8) == 'P' &&
3717 Stream.Read(8) == 'C' &&
3718 Stream.Read(8) == 'H';
3719}
3720
Richard Smith0f99d6a2015-08-09 08:48:41 +00003721static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
3722 switch (Kind) {
3723 case MK_PCH:
3724 return 0; // PCH
3725 case MK_ImplicitModule:
3726 case MK_ExplicitModule:
3727 return 1; // module
3728 case MK_MainFile:
3729 case MK_Preamble:
3730 return 2; // main source file
3731 }
3732 llvm_unreachable("unknown module kind");
3733}
3734
Guy Benyei11169dd2012-12-18 14:30:41 +00003735ASTReader::ASTReadResult
3736ASTReader::ReadASTCore(StringRef FileName,
3737 ModuleKind Type,
3738 SourceLocation ImportLoc,
3739 ModuleFile *ImportedBy,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003740 SmallVectorImpl<ImportedModule> &Loaded,
Douglas Gregor7029ce12013-03-19 00:28:20 +00003741 off_t ExpectedSize, time_t ExpectedModTime,
Ben Langmuir487ea142014-10-23 18:05:36 +00003742 ASTFileSignature ExpectedSignature,
Guy Benyei11169dd2012-12-18 14:30:41 +00003743 unsigned ClientLoadCapabilities) {
3744 ModuleFile *M;
Guy Benyei11169dd2012-12-18 14:30:41 +00003745 std::string ErrorStr;
Douglas Gregor7029ce12013-03-19 00:28:20 +00003746 ModuleManager::AddModuleResult AddResult
3747 = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
Richard Smith053f6c62014-05-16 23:01:30 +00003748 getGeneration(), ExpectedSize, ExpectedModTime,
Ben Langmuir487ea142014-10-23 18:05:36 +00003749 ExpectedSignature, readASTFileSignature,
Douglas Gregor7029ce12013-03-19 00:28:20 +00003750 M, ErrorStr);
Guy Benyei11169dd2012-12-18 14:30:41 +00003751
Douglas Gregor7029ce12013-03-19 00:28:20 +00003752 switch (AddResult) {
3753 case ModuleManager::AlreadyLoaded:
3754 return Success;
3755
3756 case ModuleManager::NewlyLoaded:
3757 // Load module file below.
3758 break;
3759
3760 case ModuleManager::Missing:
Richard Smithe842a472014-10-22 02:05:46 +00003761 // The module file was missing; if the client can handle that, return
Douglas Gregor7029ce12013-03-19 00:28:20 +00003762 // it.
3763 if (ClientLoadCapabilities & ARR_Missing)
3764 return Missing;
3765
3766 // Otherwise, return an error.
Richard Smith0f99d6a2015-08-09 08:48:41 +00003767 Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
3768 << FileName << ErrorStr.empty()
3769 << ErrorStr;
Douglas Gregor7029ce12013-03-19 00:28:20 +00003770 return Failure;
3771
3772 case ModuleManager::OutOfDate:
3773 // We couldn't load the module file because it is out-of-date. If the
3774 // client can handle out-of-date, return it.
3775 if (ClientLoadCapabilities & ARR_OutOfDate)
3776 return OutOfDate;
3777
3778 // Otherwise, return an error.
Richard Smith0f99d6a2015-08-09 08:48:41 +00003779 Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
3780 << FileName << ErrorStr.empty()
3781 << ErrorStr;
Guy Benyei11169dd2012-12-18 14:30:41 +00003782 return Failure;
3783 }
3784
Douglas Gregor7029ce12013-03-19 00:28:20 +00003785 assert(M && "Missing module file");
Guy Benyei11169dd2012-12-18 14:30:41 +00003786
3787 // FIXME: This seems rather a hack. Should CurrentDir be part of the
3788 // module?
3789 if (FileName != "-") {
3790 CurrentDir = llvm::sys::path::parent_path(FileName);
3791 if (CurrentDir.empty()) CurrentDir = ".";
3792 }
3793
3794 ModuleFile &F = *M;
Chris Lattner7fb3bef2013-01-20 00:56:42 +00003795 BitstreamCursor &Stream = F.Stream;
Adrian Prantlfb2398d2015-07-17 01:19:54 +00003796 PCHContainerRdr.ExtractPCH(F.Buffer->getMemBufferRef(), F.StreamFile);
Rafael Espindolafd832392014-11-12 14:48:44 +00003797 Stream.init(&F.StreamFile);
Adrian Prantlcbc368c2015-02-25 02:44:04 +00003798 F.SizeInBits = F.Buffer->getBufferSize() * 8;
3799
Guy Benyei11169dd2012-12-18 14:30:41 +00003800 // Sniff for the signature.
Ben Langmuir70a1b812015-03-24 04:43:52 +00003801 if (!startsWithASTFileMagic(Stream)) {
Richard Smith0f99d6a2015-08-09 08:48:41 +00003802 Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
3803 << FileName;
Guy Benyei11169dd2012-12-18 14:30:41 +00003804 return Failure;
3805 }
3806
3807 // This is used for compatibility with older PCH formats.
3808 bool HaveReadControlBlock = false;
Chris Lattnerefa77172013-01-20 00:00:22 +00003809 while (1) {
3810 llvm::BitstreamEntry Entry = Stream.advance();
3811
3812 switch (Entry.Kind) {
3813 case llvm::BitstreamEntry::Error:
Chris Lattnerefa77172013-01-20 00:00:22 +00003814 case llvm::BitstreamEntry::Record:
Douglas Gregor6623e1f2015-11-03 18:33:07 +00003815 case llvm::BitstreamEntry::EndBlock:
Guy Benyei11169dd2012-12-18 14:30:41 +00003816 Error("invalid record at top-level of AST file");
3817 return Failure;
Chris Lattnerefa77172013-01-20 00:00:22 +00003818
3819 case llvm::BitstreamEntry::SubBlock:
3820 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00003821 }
3822
Chris Lattnerefa77172013-01-20 00:00:22 +00003823 switch (Entry.ID) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003824 case CONTROL_BLOCK_ID:
3825 HaveReadControlBlock = true;
Ben Langmuirbeee15e2014-04-14 18:00:01 +00003826 switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00003827 case Success:
Richard Smith0f99d6a2015-08-09 08:48:41 +00003828 // Check that we didn't try to load a non-module AST file as a module.
3829 //
3830 // FIXME: Should we also perform the converse check? Loading a module as
3831 // a PCH file sort of works, but it's a bit wonky.
3832 if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule) &&
3833 F.ModuleName.empty()) {
3834 auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
3835 if (Result != OutOfDate ||
3836 (ClientLoadCapabilities & ARR_OutOfDate) == 0)
3837 Diag(diag::err_module_file_not_module) << FileName;
3838 return Result;
3839 }
Guy Benyei11169dd2012-12-18 14:30:41 +00003840 break;
3841
3842 case Failure: return Failure;
Douglas Gregor7029ce12013-03-19 00:28:20 +00003843 case Missing: return Missing;
Guy Benyei11169dd2012-12-18 14:30:41 +00003844 case OutOfDate: return OutOfDate;
3845 case VersionMismatch: return VersionMismatch;
3846 case ConfigurationMismatch: return ConfigurationMismatch;
3847 case HadErrors: return HadErrors;
3848 }
3849 break;
Richard Smithf8c32552015-09-02 17:45:54 +00003850
Guy Benyei11169dd2012-12-18 14:30:41 +00003851 case AST_BLOCK_ID:
3852 if (!HaveReadControlBlock) {
3853 if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
Dmitri Gribenko2228cd32014-02-11 15:40:09 +00003854 Diag(diag::err_pch_version_too_old);
Guy Benyei11169dd2012-12-18 14:30:41 +00003855 return VersionMismatch;
3856 }
3857
3858 // Record that we've loaded this module.
3859 Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
3860 return Success;
3861
3862 default:
3863 if (Stream.SkipBlock()) {
3864 Error("malformed block record in AST file");
3865 return Failure;
3866 }
3867 break;
3868 }
3869 }
Douglas Gregor6623e1f2015-11-03 18:33:07 +00003870
3871 return Success;
3872}
3873
3874/// Parse a record and blob containing module file extension metadata.
3875static bool parseModuleFileExtensionMetadata(
3876 const SmallVectorImpl<uint64_t> &Record,
3877 StringRef Blob,
3878 ModuleFileExtensionMetadata &Metadata) {
3879 if (Record.size() < 4) return true;
3880
3881 Metadata.MajorVersion = Record[0];
3882 Metadata.MinorVersion = Record[1];
3883
3884 unsigned BlockNameLen = Record[2];
3885 unsigned UserInfoLen = Record[3];
3886
3887 if (BlockNameLen + UserInfoLen > Blob.size()) return true;
3888
3889 Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
3890 Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
3891 Blob.data() + BlockNameLen + UserInfoLen);
3892 return false;
3893}
3894
3895ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
3896 BitstreamCursor &Stream = F.Stream;
3897
3898 RecordData Record;
3899 while (true) {
3900 llvm::BitstreamEntry Entry = Stream.advance();
3901 switch (Entry.Kind) {
3902 case llvm::BitstreamEntry::SubBlock:
3903 if (Stream.SkipBlock())
3904 return Failure;
3905
3906 continue;
3907
3908 case llvm::BitstreamEntry::EndBlock:
3909 return Success;
3910
3911 case llvm::BitstreamEntry::Error:
3912 return HadErrors;
3913
3914 case llvm::BitstreamEntry::Record:
3915 break;
3916 }
3917
3918 Record.clear();
3919 StringRef Blob;
3920 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
3921 switch (RecCode) {
3922 case EXTENSION_METADATA: {
3923 ModuleFileExtensionMetadata Metadata;
3924 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
3925 return Failure;
3926
3927 // Find a module file extension with this block name.
3928 auto Known = ModuleFileExtensions.find(Metadata.BlockName);
3929 if (Known == ModuleFileExtensions.end()) break;
3930
3931 // Form a reader.
3932 if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
3933 F, Stream)) {
3934 F.ExtensionReaders.push_back(std::move(Reader));
3935 }
3936
3937 break;
3938 }
3939 }
3940 }
3941
3942 return Success;
Guy Benyei11169dd2012-12-18 14:30:41 +00003943}
3944
Richard Smitha7e2cc62015-05-01 01:53:09 +00003945void ASTReader::InitializeContext() {
Guy Benyei11169dd2012-12-18 14:30:41 +00003946 // If there's a listener, notify them that we "read" the translation unit.
3947 if (DeserializationListener)
3948 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
3949 Context.getTranslationUnitDecl());
3950
Guy Benyei11169dd2012-12-18 14:30:41 +00003951 // FIXME: Find a better way to deal with collisions between these
3952 // built-in types. Right now, we just ignore the problem.
3953
3954 // Load the special types.
3955 if (SpecialTypes.size() >= NumSpecialTypeIDs) {
3956 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
3957 if (!Context.CFConstantStringTypeDecl)
3958 Context.setCFConstantStringType(GetType(String));
3959 }
3960
3961 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
3962 QualType FileType = GetType(File);
3963 if (FileType.isNull()) {
3964 Error("FILE type is NULL");
3965 return;
3966 }
3967
3968 if (!Context.FILEDecl) {
3969 if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
3970 Context.setFILEDecl(Typedef->getDecl());
3971 else {
3972 const TagType *Tag = FileType->getAs<TagType>();
3973 if (!Tag) {
3974 Error("Invalid FILE type in AST file");
3975 return;
3976 }
3977 Context.setFILEDecl(Tag->getDecl());
3978 }
3979 }
3980 }
3981
3982 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
3983 QualType Jmp_bufType = GetType(Jmp_buf);
3984 if (Jmp_bufType.isNull()) {
3985 Error("jmp_buf type is NULL");
3986 return;
3987 }
3988
3989 if (!Context.jmp_bufDecl) {
3990 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
3991 Context.setjmp_bufDecl(Typedef->getDecl());
3992 else {
3993 const TagType *Tag = Jmp_bufType->getAs<TagType>();
3994 if (!Tag) {
3995 Error("Invalid jmp_buf type in AST file");
3996 return;
3997 }
3998 Context.setjmp_bufDecl(Tag->getDecl());
3999 }
4000 }
4001 }
4002
4003 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
4004 QualType Sigjmp_bufType = GetType(Sigjmp_buf);
4005 if (Sigjmp_bufType.isNull()) {
4006 Error("sigjmp_buf type is NULL");
4007 return;
4008 }
4009
4010 if (!Context.sigjmp_bufDecl) {
4011 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
4012 Context.setsigjmp_bufDecl(Typedef->getDecl());
4013 else {
4014 const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
4015 assert(Tag && "Invalid sigjmp_buf type in AST file");
4016 Context.setsigjmp_bufDecl(Tag->getDecl());
4017 }
4018 }
4019 }
4020
4021 if (unsigned ObjCIdRedef
4022 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
4023 if (Context.ObjCIdRedefinitionType.isNull())
4024 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
4025 }
4026
4027 if (unsigned ObjCClassRedef
4028 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
4029 if (Context.ObjCClassRedefinitionType.isNull())
4030 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
4031 }
4032
4033 if (unsigned ObjCSelRedef
4034 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
4035 if (Context.ObjCSelRedefinitionType.isNull())
4036 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
4037 }
4038
4039 if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
4040 QualType Ucontext_tType = GetType(Ucontext_t);
4041 if (Ucontext_tType.isNull()) {
4042 Error("ucontext_t type is NULL");
4043 return;
4044 }
4045
4046 if (!Context.ucontext_tDecl) {
4047 if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
4048 Context.setucontext_tDecl(Typedef->getDecl());
4049 else {
4050 const TagType *Tag = Ucontext_tType->getAs<TagType>();
4051 assert(Tag && "Invalid ucontext_t type in AST file");
4052 Context.setucontext_tDecl(Tag->getDecl());
4053 }
4054 }
4055 }
4056 }
4057
4058 ReadPragmaDiagnosticMappings(Context.getDiagnostics());
4059
4060 // If there were any CUDA special declarations, deserialize them.
4061 if (!CUDASpecialDeclRefs.empty()) {
4062 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
4063 Context.setcudaConfigureCallDecl(
4064 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
4065 }
Richard Smith56be7542014-03-21 00:33:59 +00004066
Guy Benyei11169dd2012-12-18 14:30:41 +00004067 // Re-export any modules that were imported by a non-module AST file.
Richard Smitha7e2cc62015-05-01 01:53:09 +00004068 // FIXME: This does not make macro-only imports visible again.
Richard Smith56be7542014-03-21 00:33:59 +00004069 for (auto &Import : ImportedModules) {
Richard Smitha7e2cc62015-05-01 01:53:09 +00004070 if (Module *Imported = getSubmodule(Import.ID)) {
Argyrios Kyrtzidis125df052013-02-01 16:36:12 +00004071 makeModuleVisible(Imported, Module::AllVisible,
Richard Smitha7e2cc62015-05-01 01:53:09 +00004072 /*ImportLoc=*/Import.ImportLoc);
Ben Langmuir6d25fdc2016-02-11 17:04:42 +00004073 if (Import.ImportLoc.isValid())
4074 PP.makeModuleVisible(Imported, Import.ImportLoc);
4075 // FIXME: should we tell Sema to make the module visible too?
Richard Smitha7e2cc62015-05-01 01:53:09 +00004076 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004077 }
4078 ImportedModules.clear();
4079}
4080
4081void ASTReader::finalizeForWriting() {
Richard Smithde711422015-04-23 21:20:19 +00004082 // Nothing to do for now.
Guy Benyei11169dd2012-12-18 14:30:41 +00004083}
4084
Ben Langmuir70a1b812015-03-24 04:43:52 +00004085/// \brief Reads and return the signature record from \p StreamFile's control
4086/// block, or else returns 0.
Ben Langmuir487ea142014-10-23 18:05:36 +00004087static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){
4088 BitstreamCursor Stream(StreamFile);
Ben Langmuir70a1b812015-03-24 04:43:52 +00004089 if (!startsWithASTFileMagic(Stream))
Ben Langmuir487ea142014-10-23 18:05:36 +00004090 return 0;
Ben Langmuir487ea142014-10-23 18:05:36 +00004091
4092 // Scan for the CONTROL_BLOCK_ID block.
4093 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
4094 return 0;
4095
4096 // Scan for SIGNATURE inside the control block.
4097 ASTReader::RecordData Record;
4098 while (1) {
4099 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
4100 if (Entry.Kind == llvm::BitstreamEntry::EndBlock ||
4101 Entry.Kind != llvm::BitstreamEntry::Record)
4102 return 0;
4103
4104 Record.clear();
4105 StringRef Blob;
4106 if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
4107 return Record[0];
4108 }
4109}
4110
Guy Benyei11169dd2012-12-18 14:30:41 +00004111/// \brief Retrieve the name of the original source file name
4112/// directly from the AST file, without actually loading the AST
4113/// file.
Adrian Prantlbb165fb2015-06-20 18:53:08 +00004114std::string ASTReader::getOriginalSourceFile(
4115 const std::string &ASTFileName, FileManager &FileMgr,
Adrian Prantlfb2398d2015-07-17 01:19:54 +00004116 const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004117 // Open the AST file.
Benjamin Kramera8857962014-10-26 22:44:13 +00004118 auto Buffer = FileMgr.getBufferForFile(ASTFileName);
Guy Benyei11169dd2012-12-18 14:30:41 +00004119 if (!Buffer) {
Benjamin Kramera8857962014-10-26 22:44:13 +00004120 Diags.Report(diag::err_fe_unable_to_read_pch_file)
4121 << ASTFileName << Buffer.getError().message();
Guy Benyei11169dd2012-12-18 14:30:41 +00004122 return std::string();
4123 }
4124
4125 // Initialize the stream
4126 llvm::BitstreamReader StreamFile;
Adrian Prantlfb2398d2015-07-17 01:19:54 +00004127 PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
Rafael Espindolaaf0e40a2014-11-12 14:42:25 +00004128 BitstreamCursor Stream(StreamFile);
Guy Benyei11169dd2012-12-18 14:30:41 +00004129
4130 // Sniff for the signature.
Ben Langmuir70a1b812015-03-24 04:43:52 +00004131 if (!startsWithASTFileMagic(Stream)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004132 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
4133 return std::string();
4134 }
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004135
Chris Lattnere7b154b2013-01-19 21:39:22 +00004136 // Scan for the CONTROL_BLOCK_ID block.
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004137 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004138 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4139 return std::string();
Chris Lattnere7b154b2013-01-19 21:39:22 +00004140 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004141
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004142 // Scan for ORIGINAL_FILE inside the control block.
4143 RecordData Record;
Chris Lattnere7b154b2013-01-19 21:39:22 +00004144 while (1) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004145 llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
Chris Lattnere7b154b2013-01-19 21:39:22 +00004146 if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
4147 return std::string();
4148
4149 if (Entry.Kind != llvm::BitstreamEntry::Record) {
4150 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
4151 return std::string();
Guy Benyei11169dd2012-12-18 14:30:41 +00004152 }
Chris Lattnere7b154b2013-01-19 21:39:22 +00004153
Guy Benyei11169dd2012-12-18 14:30:41 +00004154 Record.clear();
Chris Lattner0e6c9402013-01-20 02:38:54 +00004155 StringRef Blob;
4156 if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
4157 return Blob.str();
Guy Benyei11169dd2012-12-18 14:30:41 +00004158 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004159}
4160
4161namespace {
4162 class SimplePCHValidator : public ASTReaderListener {
4163 const LangOptions &ExistingLangOpts;
4164 const TargetOptions &ExistingTargetOpts;
4165 const PreprocessorOptions &ExistingPPOpts;
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004166 std::string ExistingModuleCachePath;
Guy Benyei11169dd2012-12-18 14:30:41 +00004167 FileManager &FileMgr;
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004168
Guy Benyei11169dd2012-12-18 14:30:41 +00004169 public:
4170 SimplePCHValidator(const LangOptions &ExistingLangOpts,
4171 const TargetOptions &ExistingTargetOpts,
4172 const PreprocessorOptions &ExistingPPOpts,
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004173 StringRef ExistingModuleCachePath,
Guy Benyei11169dd2012-12-18 14:30:41 +00004174 FileManager &FileMgr)
4175 : ExistingLangOpts(ExistingLangOpts),
4176 ExistingTargetOpts(ExistingTargetOpts),
4177 ExistingPPOpts(ExistingPPOpts),
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004178 ExistingModuleCachePath(ExistingModuleCachePath),
Guy Benyei11169dd2012-12-18 14:30:41 +00004179 FileMgr(FileMgr)
4180 {
4181 }
4182
Richard Smith1e2cf0d2014-10-31 02:28:58 +00004183 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
4184 bool AllowCompatibleDifferences) override {
4185 return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
4186 AllowCompatibleDifferences);
Guy Benyei11169dd2012-12-18 14:30:41 +00004187 }
Chandler Carruth0d745bc2015-03-14 04:47:43 +00004188 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
4189 bool AllowCompatibleDifferences) override {
4190 return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
4191 AllowCompatibleDifferences);
Guy Benyei11169dd2012-12-18 14:30:41 +00004192 }
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004193 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
4194 StringRef SpecificModuleCachePath,
4195 bool Complain) override {
4196 return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4197 ExistingModuleCachePath,
4198 nullptr, ExistingLangOpts);
4199 }
Craig Topper3e89dfe2014-03-13 02:13:41 +00004200 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
4201 bool Complain,
4202 std::string &SuggestedPredefines) override {
Craig Toppera13603a2014-05-22 05:54:18 +00004203 return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
Argyrios Kyrtzidisd3afa0c2013-04-26 21:33:40 +00004204 SuggestedPredefines, ExistingLangOpts);
Guy Benyei11169dd2012-12-18 14:30:41 +00004205 }
4206 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00004207}
Guy Benyei11169dd2012-12-18 14:30:41 +00004208
Adrian Prantlbb165fb2015-06-20 18:53:08 +00004209bool ASTReader::readASTFileControlBlock(
4210 StringRef Filename, FileManager &FileMgr,
Adrian Prantlfb2398d2015-07-17 01:19:54 +00004211 const PCHContainerReader &PCHContainerRdr,
Douglas Gregor6623e1f2015-11-03 18:33:07 +00004212 bool FindModuleFileExtensions,
Adrian Prantlbb165fb2015-06-20 18:53:08 +00004213 ASTReaderListener &Listener) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004214 // Open the AST file.
Richard Smith7f330cd2015-03-18 01:42:29 +00004215 // FIXME: This allows use of the VFS; we do not allow use of the
4216 // VFS when actually loading a module.
Benjamin Kramera8857962014-10-26 22:44:13 +00004217 auto Buffer = FileMgr.getBufferForFile(Filename);
Guy Benyei11169dd2012-12-18 14:30:41 +00004218 if (!Buffer) {
4219 return true;
4220 }
4221
4222 // Initialize the stream
4223 llvm::BitstreamReader StreamFile;
Adrian Prantlfb2398d2015-07-17 01:19:54 +00004224 PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
Rafael Espindolaaf0e40a2014-11-12 14:42:25 +00004225 BitstreamCursor Stream(StreamFile);
Guy Benyei11169dd2012-12-18 14:30:41 +00004226
4227 // Sniff for the signature.
Ben Langmuir70a1b812015-03-24 04:43:52 +00004228 if (!startsWithASTFileMagic(Stream))
Guy Benyei11169dd2012-12-18 14:30:41 +00004229 return true;
Guy Benyei11169dd2012-12-18 14:30:41 +00004230
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004231 // Scan for the CONTROL_BLOCK_ID block.
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004232 if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004233 return true;
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004234
4235 bool NeedsInputFiles = Listener.needsInputFileVisitation();
Ben Langmuircb69b572014-03-07 06:40:32 +00004236 bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
Richard Smithd4b230b2014-10-27 23:01:16 +00004237 bool NeedsImports = Listener.needsImportVisitation();
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004238 BitstreamCursor InputFilesCursor;
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004239
Guy Benyei11169dd2012-12-18 14:30:41 +00004240 RecordData Record;
Richard Smith7ed1bc92014-12-05 22:42:13 +00004241 std::string ModuleDir;
Douglas Gregor6623e1f2015-11-03 18:33:07 +00004242 bool DoneWithControlBlock = false;
4243 while (!DoneWithControlBlock) {
Richard Smith0516b182015-09-08 19:40:14 +00004244 llvm::BitstreamEntry Entry = Stream.advance();
4245
4246 switch (Entry.Kind) {
4247 case llvm::BitstreamEntry::SubBlock: {
4248 switch (Entry.ID) {
4249 case OPTIONS_BLOCK_ID: {
4250 std::string IgnoredSuggestedPredefines;
4251 if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
4252 /*AllowCompatibleConfigurationMismatch*/ false,
4253 Listener, IgnoredSuggestedPredefines) != Success)
4254 return true;
4255 break;
4256 }
4257
4258 case INPUT_FILES_BLOCK_ID:
4259 InputFilesCursor = Stream;
4260 if (Stream.SkipBlock() ||
4261 (NeedsInputFiles &&
4262 ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
4263 return true;
4264 break;
4265
4266 default:
4267 if (Stream.SkipBlock())
4268 return true;
4269 break;
4270 }
4271
4272 continue;
4273 }
4274
4275 case llvm::BitstreamEntry::EndBlock:
Douglas Gregor6623e1f2015-11-03 18:33:07 +00004276 DoneWithControlBlock = true;
4277 break;
Richard Smith0516b182015-09-08 19:40:14 +00004278
4279 case llvm::BitstreamEntry::Error:
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004280 return true;
Richard Smith0516b182015-09-08 19:40:14 +00004281
4282 case llvm::BitstreamEntry::Record:
4283 break;
4284 }
4285
Douglas Gregor6623e1f2015-11-03 18:33:07 +00004286 if (DoneWithControlBlock) break;
4287
Guy Benyei11169dd2012-12-18 14:30:41 +00004288 Record.clear();
Chris Lattner0e6c9402013-01-20 02:38:54 +00004289 StringRef Blob;
4290 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004291 switch ((ControlRecordTypes)RecCode) {
4292 case METADATA: {
4293 if (Record[0] != VERSION_MAJOR)
4294 return true;
Guy Benyei11169dd2012-12-18 14:30:41 +00004295
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004296 if (Listener.ReadFullVersionInformation(Blob))
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004297 return true;
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00004298
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004299 break;
4300 }
Ben Langmuir4f5212a2014-04-14 22:12:44 +00004301 case MODULE_NAME:
4302 Listener.ReadModuleName(Blob);
4303 break;
Richard Smith7ed1bc92014-12-05 22:42:13 +00004304 case MODULE_DIRECTORY:
4305 ModuleDir = Blob;
4306 break;
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00004307 case MODULE_MAP_FILE: {
4308 unsigned Idx = 0;
Richard Smith7ed1bc92014-12-05 22:42:13 +00004309 auto Path = ReadString(Record, Idx);
4310 ResolveImportedPath(Path, ModuleDir);
4311 Listener.ReadModuleMapFile(Path);
Ben Langmuir4f5212a2014-04-14 22:12:44 +00004312 break;
Ben Langmuir4b8a9e92014-08-12 16:42:33 +00004313 }
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004314 case INPUT_FILE_OFFSETS: {
4315 if (!NeedsInputFiles)
4316 break;
4317
4318 unsigned NumInputFiles = Record[0];
4319 unsigned NumUserFiles = Record[1];
Richard Smithec216502015-02-13 19:48:37 +00004320 const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004321 for (unsigned I = 0; I != NumInputFiles; ++I) {
4322 // Go find this input file.
4323 bool isSystemFile = I >= NumUserFiles;
Ben Langmuircb69b572014-03-07 06:40:32 +00004324
4325 if (isSystemFile && !NeedsSystemInputFiles)
4326 break; // the rest are system input files
4327
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004328 BitstreamCursor &Cursor = InputFilesCursor;
4329 SavedStreamPosition SavedPosition(Cursor);
4330 Cursor.JumpToBit(InputFileOffs[I]);
4331
4332 unsigned Code = Cursor.ReadCode();
4333 RecordData Record;
4334 StringRef Blob;
4335 bool shouldContinue = false;
4336 switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
4337 case INPUT_FILE:
Argyrios Kyrtzidis68ccbe02014-03-14 02:26:31 +00004338 bool Overridden = static_cast<bool>(Record[3]);
Richard Smith7ed1bc92014-12-05 22:42:13 +00004339 std::string Filename = Blob;
4340 ResolveImportedPath(Filename, ModuleDir);
Richard Smith216a3bd2015-08-13 17:57:10 +00004341 shouldContinue = Listener.visitInputFile(
4342 Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
Argyrios Kyrtzidisc4cd2c42013-05-06 19:23:40 +00004343 break;
4344 }
4345 if (!shouldContinue)
4346 break;
4347 }
4348 break;
4349 }
4350
Richard Smithd4b230b2014-10-27 23:01:16 +00004351 case IMPORTS: {
4352 if (!NeedsImports)
4353 break;
4354
4355 unsigned Idx = 0, N = Record.size();
4356 while (Idx < N) {
4357 // Read information about the AST file.
Richard Smith79c98cc2014-10-27 23:25:15 +00004358 Idx += 5; // ImportLoc, Size, ModTime, Signature
Richard Smith7ed1bc92014-12-05 22:42:13 +00004359 std::string Filename = ReadString(Record, Idx);
4360 ResolveImportedPath(Filename, ModuleDir);
4361 Listener.visitImport(Filename);
Richard Smithd4b230b2014-10-27 23:01:16 +00004362 }
4363 break;
4364 }
4365
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004366 default:
4367 // No other validation to perform.
4368 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00004369 }
4370 }
Douglas Gregor6623e1f2015-11-03 18:33:07 +00004371
4372 // Look for module file extension blocks, if requested.
4373 if (FindModuleFileExtensions) {
4374 while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
4375 bool DoneWithExtensionBlock = false;
4376 while (!DoneWithExtensionBlock) {
4377 llvm::BitstreamEntry Entry = Stream.advance();
4378
4379 switch (Entry.Kind) {
4380 case llvm::BitstreamEntry::SubBlock:
4381 if (Stream.SkipBlock())
4382 return true;
4383
4384 continue;
4385
4386 case llvm::BitstreamEntry::EndBlock:
4387 DoneWithExtensionBlock = true;
4388 continue;
4389
4390 case llvm::BitstreamEntry::Error:
4391 return true;
4392
4393 case llvm::BitstreamEntry::Record:
4394 break;
4395 }
4396
4397 Record.clear();
4398 StringRef Blob;
4399 unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
4400 switch (RecCode) {
4401 case EXTENSION_METADATA: {
4402 ModuleFileExtensionMetadata Metadata;
4403 if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
4404 return true;
4405
4406 Listener.readModuleFileExtension(Metadata);
4407 break;
4408 }
4409 }
4410 }
4411 }
4412 }
4413
4414 return false;
Guy Benyei11169dd2012-12-18 14:30:41 +00004415}
4416
Adrian Prantlbb165fb2015-06-20 18:53:08 +00004417bool ASTReader::isAcceptableASTFile(
4418 StringRef Filename, FileManager &FileMgr,
Adrian Prantlfb2398d2015-07-17 01:19:54 +00004419 const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts,
Adrian Prantlbb165fb2015-06-20 18:53:08 +00004420 const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts,
4421 std::string ExistingModuleCachePath) {
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004422 SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
4423 ExistingModuleCachePath, FileMgr);
Adrian Prantlfb2398d2015-07-17 01:19:54 +00004424 return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
Douglas Gregor6623e1f2015-11-03 18:33:07 +00004425 /*FindModuleFileExtensions=*/false,
Adrian Prantlbb165fb2015-06-20 18:53:08 +00004426 validator);
Guy Benyei11169dd2012-12-18 14:30:41 +00004427}
4428
Ben Langmuir2c9af442014-04-10 17:57:43 +00004429ASTReader::ASTReadResult
4430ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004431 // Enter the submodule block.
4432 if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
4433 Error("malformed submodule block record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00004434 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00004435 }
4436
4437 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
4438 bool First = true;
Craig Toppera13603a2014-05-22 05:54:18 +00004439 Module *CurrentModule = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00004440 RecordData Record;
4441 while (true) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004442 llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
4443
4444 switch (Entry.Kind) {
4445 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
4446 case llvm::BitstreamEntry::Error:
4447 Error("malformed block record in AST file");
Ben Langmuir2c9af442014-04-10 17:57:43 +00004448 return Failure;
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004449 case llvm::BitstreamEntry::EndBlock:
Ben Langmuir2c9af442014-04-10 17:57:43 +00004450 return Success;
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004451 case llvm::BitstreamEntry::Record:
4452 // The interesting case.
4453 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00004454 }
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004455
Guy Benyei11169dd2012-12-18 14:30:41 +00004456 // Read a record.
Chris Lattner0e6c9402013-01-20 02:38:54 +00004457 StringRef Blob;
Guy Benyei11169dd2012-12-18 14:30:41 +00004458 Record.clear();
Richard Smith03478d92014-10-23 22:12:14 +00004459 auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
4460
4461 if ((Kind == SUBMODULE_METADATA) != First) {
4462 Error("submodule metadata record should be at beginning of block");
4463 return Failure;
4464 }
4465 First = false;
4466
4467 // Submodule information is only valid if we have a current module.
4468 // FIXME: Should we error on these cases?
4469 if (!CurrentModule && Kind != SUBMODULE_METADATA &&
4470 Kind != SUBMODULE_DEFINITION)
4471 continue;
4472
4473 switch (Kind) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004474 default: // Default behavior: ignore.
4475 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00004476
Richard Smith03478d92014-10-23 22:12:14 +00004477 case SUBMODULE_DEFINITION: {
Douglas Gregor8d932422013-03-20 03:59:18 +00004478 if (Record.size() < 8) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004479 Error("malformed module definition");
Ben Langmuir2c9af442014-04-10 17:57:43 +00004480 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00004481 }
Richard Smith03478d92014-10-23 22:12:14 +00004482
Chris Lattner0e6c9402013-01-20 02:38:54 +00004483 StringRef Name = Blob;
Richard Smith9bca2982014-03-08 00:03:56 +00004484 unsigned Idx = 0;
4485 SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
4486 SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
4487 bool IsFramework = Record[Idx++];
4488 bool IsExplicit = Record[Idx++];
4489 bool IsSystem = Record[Idx++];
4490 bool IsExternC = Record[Idx++];
4491 bool InferSubmodules = Record[Idx++];
4492 bool InferExplicitSubmodules = Record[Idx++];
4493 bool InferExportWildcard = Record[Idx++];
4494 bool ConfigMacrosExhaustive = Record[Idx++];
Douglas Gregor8d932422013-03-20 03:59:18 +00004495
Ben Langmuirbeee15e2014-04-14 18:00:01 +00004496 Module *ParentModule = nullptr;
Ben Langmuir9d6448b2014-08-09 00:57:23 +00004497 if (Parent)
Guy Benyei11169dd2012-12-18 14:30:41 +00004498 ParentModule = getSubmodule(Parent);
Ben Langmuirbeee15e2014-04-14 18:00:01 +00004499
Guy Benyei11169dd2012-12-18 14:30:41 +00004500 // Retrieve this (sub)module from the module map, creating it if
4501 // necessary.
Ben Langmuir9d6448b2014-08-09 00:57:23 +00004502 CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
Guy Benyei11169dd2012-12-18 14:30:41 +00004503 IsExplicit).first;
Ben Langmuir9d6448b2014-08-09 00:57:23 +00004504
4505 // FIXME: set the definition loc for CurrentModule, or call
4506 // ModMap.setInferredModuleAllowedBy()
4507
Guy Benyei11169dd2012-12-18 14:30:41 +00004508 SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
4509 if (GlobalIndex >= SubmodulesLoaded.size() ||
4510 SubmodulesLoaded[GlobalIndex]) {
4511 Error("too many submodules");
Ben Langmuir2c9af442014-04-10 17:57:43 +00004512 return Failure;
Guy Benyei11169dd2012-12-18 14:30:41 +00004513 }
Douglas Gregor8a114ab2013-02-06 22:40:31 +00004514
Douglas Gregor7029ce12013-03-19 00:28:20 +00004515 if (!ParentModule) {
4516 if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
4517 if (CurFile != F.File) {
4518 if (!Diags.isDiagnosticInFlight()) {
4519 Diag(diag::err_module_file_conflict)
4520 << CurrentModule->getTopLevelModuleName()
4521 << CurFile->getName()
4522 << F.File->getName();
4523 }
Ben Langmuir2c9af442014-04-10 17:57:43 +00004524 return Failure;
Douglas Gregor8a114ab2013-02-06 22:40:31 +00004525 }
Douglas Gregor8a114ab2013-02-06 22:40:31 +00004526 }
Douglas Gregor7029ce12013-03-19 00:28:20 +00004527
4528 CurrentModule->setASTFile(F.File);
Douglas Gregor8a114ab2013-02-06 22:40:31 +00004529 }
Ben Langmuirbeee15e2014-04-14 18:00:01 +00004530
Adrian Prantl15bcf702015-06-30 17:39:43 +00004531 CurrentModule->Signature = F.Signature;
Guy Benyei11169dd2012-12-18 14:30:41 +00004532 CurrentModule->IsFromModuleFile = true;
4533 CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
Richard Smith9bca2982014-03-08 00:03:56 +00004534 CurrentModule->IsExternC = IsExternC;
Guy Benyei11169dd2012-12-18 14:30:41 +00004535 CurrentModule->InferSubmodules = InferSubmodules;
4536 CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
4537 CurrentModule->InferExportWildcard = InferExportWildcard;
Douglas Gregor8d932422013-03-20 03:59:18 +00004538 CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
Guy Benyei11169dd2012-12-18 14:30:41 +00004539 if (DeserializationListener)
4540 DeserializationListener->ModuleRead(GlobalID, CurrentModule);
4541
4542 SubmodulesLoaded[GlobalIndex] = CurrentModule;
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004543
Douglas Gregorfb912652013-03-20 21:10:35 +00004544 // Clear out data that will be replaced by what is the module file.
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004545 CurrentModule->LinkLibraries.clear();
Douglas Gregor8d932422013-03-20 03:59:18 +00004546 CurrentModule->ConfigMacros.clear();
Douglas Gregorfb912652013-03-20 21:10:35 +00004547 CurrentModule->UnresolvedConflicts.clear();
4548 CurrentModule->Conflicts.clear();
Guy Benyei11169dd2012-12-18 14:30:41 +00004549 break;
4550 }
4551
4552 case SUBMODULE_UMBRELLA_HEADER: {
Richard Smith2b63d152015-05-16 02:28:53 +00004553 std::string Filename = Blob;
4554 ResolveImportedPath(F, Filename);
4555 if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004556 if (!CurrentModule->getUmbrellaHeader())
Richard Smith2b63d152015-05-16 02:28:53 +00004557 ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
4558 else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
Ben Langmuirbc35fbe2015-02-20 21:46:39 +00004559 // This can be a spurious difference caused by changing the VFS to
4560 // point to a different copy of the file, and it is too late to
4561 // to rebuild safely.
4562 // FIXME: If we wrote the virtual paths instead of the 'real' paths,
4563 // after input file validation only real problems would remain and we
4564 // could just error. For now, assume it's okay.
4565 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00004566 }
4567 }
4568 break;
4569 }
4570
Richard Smith202210b2014-10-24 20:23:01 +00004571 case SUBMODULE_HEADER:
4572 case SUBMODULE_EXCLUDED_HEADER:
4573 case SUBMODULE_PRIVATE_HEADER:
4574 // We lazily associate headers with their modules via the HeaderInfo table.
Argyrios Kyrtzidisb146baa2013-03-13 21:13:51 +00004575 // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
4576 // of complete filenames or remove it entirely.
Richard Smith202210b2014-10-24 20:23:01 +00004577 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00004578
Richard Smith202210b2014-10-24 20:23:01 +00004579 case SUBMODULE_TEXTUAL_HEADER:
4580 case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
4581 // FIXME: Textual headers are not marked in the HeaderInfo table. Load
4582 // them here.
4583 break;
Lawrence Crowlb53e5482013-06-20 21:14:14 +00004584
Guy Benyei11169dd2012-12-18 14:30:41 +00004585 case SUBMODULE_TOPHEADER: {
Argyrios Kyrtzidis3c5305c2013-03-13 21:13:43 +00004586 CurrentModule->addTopHeaderFilename(Blob);
Guy Benyei11169dd2012-12-18 14:30:41 +00004587 break;
4588 }
4589
4590 case SUBMODULE_UMBRELLA_DIR: {
Richard Smith2b63d152015-05-16 02:28:53 +00004591 std::string Dirname = Blob;
4592 ResolveImportedPath(F, Dirname);
4593 if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004594 if (!CurrentModule->getUmbrellaDir())
Richard Smith2b63d152015-05-16 02:28:53 +00004595 ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
4596 else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
Ben Langmuir2c9af442014-04-10 17:57:43 +00004597 if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
4598 Error("mismatched umbrella directories in submodule");
4599 return OutOfDate;
Guy Benyei11169dd2012-12-18 14:30:41 +00004600 }
4601 }
4602 break;
4603 }
4604
4605 case SUBMODULE_METADATA: {
Guy Benyei11169dd2012-12-18 14:30:41 +00004606 F.BaseSubmoduleID = getTotalNumSubmodules();
4607 F.LocalNumSubmodules = Record[0];
4608 unsigned LocalBaseSubmoduleID = Record[1];
4609 if (F.LocalNumSubmodules > 0) {
4610 // Introduce the global -> local mapping for submodules within this
4611 // module.
4612 GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
4613
4614 // Introduce the local -> global mapping for submodules within this
4615 // module.
4616 F.SubmoduleRemap.insertOrReplace(
4617 std::make_pair(LocalBaseSubmoduleID,
4618 F.BaseSubmoduleID - LocalBaseSubmoduleID));
Ben Langmuirfe971d92014-08-16 04:54:18 +00004619
Ben Langmuir52ca6782014-10-20 16:27:32 +00004620 SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
4621 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004622 break;
4623 }
4624
4625 case SUBMODULE_IMPORTS: {
Guy Benyei11169dd2012-12-18 14:30:41 +00004626 for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
Douglas Gregorfb912652013-03-20 21:10:35 +00004627 UnresolvedModuleRef Unresolved;
Guy Benyei11169dd2012-12-18 14:30:41 +00004628 Unresolved.File = &F;
4629 Unresolved.Mod = CurrentModule;
4630 Unresolved.ID = Record[Idx];
Douglas Gregorfb912652013-03-20 21:10:35 +00004631 Unresolved.Kind = UnresolvedModuleRef::Import;
Guy Benyei11169dd2012-12-18 14:30:41 +00004632 Unresolved.IsWildcard = false;
Douglas Gregorfb912652013-03-20 21:10:35 +00004633 UnresolvedModuleRefs.push_back(Unresolved);
Guy Benyei11169dd2012-12-18 14:30:41 +00004634 }
4635 break;
4636 }
4637
4638 case SUBMODULE_EXPORTS: {
Guy Benyei11169dd2012-12-18 14:30:41 +00004639 for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
Douglas Gregorfb912652013-03-20 21:10:35 +00004640 UnresolvedModuleRef Unresolved;
Guy Benyei11169dd2012-12-18 14:30:41 +00004641 Unresolved.File = &F;
4642 Unresolved.Mod = CurrentModule;
4643 Unresolved.ID = Record[Idx];
Douglas Gregorfb912652013-03-20 21:10:35 +00004644 Unresolved.Kind = UnresolvedModuleRef::Export;
Guy Benyei11169dd2012-12-18 14:30:41 +00004645 Unresolved.IsWildcard = Record[Idx + 1];
Douglas Gregorfb912652013-03-20 21:10:35 +00004646 UnresolvedModuleRefs.push_back(Unresolved);
Guy Benyei11169dd2012-12-18 14:30:41 +00004647 }
4648
4649 // Once we've loaded the set of exports, there's no reason to keep
4650 // the parsed, unresolved exports around.
4651 CurrentModule->UnresolvedExports.clear();
4652 break;
4653 }
4654 case SUBMODULE_REQUIRES: {
Richard Smitha3feee22013-10-28 22:18:19 +00004655 CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
Guy Benyei11169dd2012-12-18 14:30:41 +00004656 Context.getTargetInfo());
4657 break;
4658 }
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004659
4660 case SUBMODULE_LINK_LIBRARY:
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004661 CurrentModule->LinkLibraries.push_back(
Chris Lattner0e6c9402013-01-20 02:38:54 +00004662 Module::LinkLibrary(Blob, Record[0]));
Douglas Gregor6ddfca92013-01-14 17:21:00 +00004663 break;
Douglas Gregor35b13ec2013-03-20 00:22:05 +00004664
4665 case SUBMODULE_CONFIG_MACRO:
Douglas Gregor35b13ec2013-03-20 00:22:05 +00004666 CurrentModule->ConfigMacros.push_back(Blob.str());
4667 break;
Douglas Gregorfb912652013-03-20 21:10:35 +00004668
4669 case SUBMODULE_CONFLICT: {
Douglas Gregorfb912652013-03-20 21:10:35 +00004670 UnresolvedModuleRef Unresolved;
4671 Unresolved.File = &F;
4672 Unresolved.Mod = CurrentModule;
4673 Unresolved.ID = Record[0];
4674 Unresolved.Kind = UnresolvedModuleRef::Conflict;
4675 Unresolved.IsWildcard = false;
4676 Unresolved.String = Blob;
4677 UnresolvedModuleRefs.push_back(Unresolved);
4678 break;
4679 }
Guy Benyei11169dd2012-12-18 14:30:41 +00004680 }
4681 }
4682}
4683
4684/// \brief Parse the record that corresponds to a LangOptions data
4685/// structure.
4686///
4687/// This routine parses the language options from the AST file and then gives
4688/// them to the AST listener if one is set.
4689///
4690/// \returns true if the listener deems the file unacceptable, false otherwise.
4691bool ASTReader::ParseLanguageOptions(const RecordData &Record,
4692 bool Complain,
Richard Smith1e2cf0d2014-10-31 02:28:58 +00004693 ASTReaderListener &Listener,
4694 bool AllowCompatibleDifferences) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004695 LangOptions LangOpts;
4696 unsigned Idx = 0;
4697#define LANGOPT(Name, Bits, Default, Description) \
4698 LangOpts.Name = Record[Idx++];
4699#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4700 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
4701#include "clang/Basic/LangOptions.def"
Alexey Samsonovedf99a92014-11-07 22:29:38 +00004702#define SANITIZER(NAME, ID) \
4703 LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
Will Dietzf54319c2013-01-18 11:30:38 +00004704#include "clang/Basic/Sanitizers.def"
Guy Benyei11169dd2012-12-18 14:30:41 +00004705
Ben Langmuircd98cb72015-06-23 18:20:18 +00004706 for (unsigned N = Record[Idx++]; N; --N)
4707 LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
4708
Guy Benyei11169dd2012-12-18 14:30:41 +00004709 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
4710 VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
4711 LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004712
Ben Langmuird4a667a2015-06-23 18:20:23 +00004713 LangOpts.CurrentModule = ReadString(Record, Idx);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004714
4715 // Comment options.
4716 for (unsigned N = Record[Idx++]; N; --N) {
4717 LangOpts.CommentOpts.BlockCommandNames.push_back(
4718 ReadString(Record, Idx));
4719 }
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00004720 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +00004721
Samuel Antaoee8fb302016-01-06 13:42:12 +00004722 // OpenMP offloading options.
4723 for (unsigned N = Record[Idx++]; N; --N) {
4724 LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
4725 }
4726
4727 LangOpts.OMPHostIRFile = ReadString(Record, Idx);
4728
Richard Smith1e2cf0d2014-10-31 02:28:58 +00004729 return Listener.ReadLanguageOptions(LangOpts, Complain,
4730 AllowCompatibleDifferences);
Guy Benyei11169dd2012-12-18 14:30:41 +00004731}
4732
Chandler Carruth0d745bc2015-03-14 04:47:43 +00004733bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
4734 ASTReaderListener &Listener,
4735 bool AllowCompatibleDifferences) {
Guy Benyei11169dd2012-12-18 14:30:41 +00004736 unsigned Idx = 0;
4737 TargetOptions TargetOpts;
4738 TargetOpts.Triple = ReadString(Record, Idx);
4739 TargetOpts.CPU = ReadString(Record, Idx);
4740 TargetOpts.ABI = ReadString(Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00004741 for (unsigned N = Record[Idx++]; N; --N) {
4742 TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
4743 }
4744 for (unsigned N = Record[Idx++]; N; --N) {
4745 TargetOpts.Features.push_back(ReadString(Record, Idx));
4746 }
4747
Chandler Carruth0d745bc2015-03-14 04:47:43 +00004748 return Listener.ReadTargetOptions(TargetOpts, Complain,
4749 AllowCompatibleDifferences);
Guy Benyei11169dd2012-12-18 14:30:41 +00004750}
4751
4752bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
4753 ASTReaderListener &Listener) {
Ben Langmuirb92de022014-04-29 16:25:26 +00004754 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
Guy Benyei11169dd2012-12-18 14:30:41 +00004755 unsigned Idx = 0;
Ben Langmuirb92de022014-04-29 16:25:26 +00004756#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
Guy Benyei11169dd2012-12-18 14:30:41 +00004757#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
Ben Langmuirb92de022014-04-29 16:25:26 +00004758 DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
Guy Benyei11169dd2012-12-18 14:30:41 +00004759#include "clang/Basic/DiagnosticOptions.def"
4760
Richard Smith3be1cb22014-08-07 00:24:21 +00004761 for (unsigned N = Record[Idx++]; N; --N)
Ben Langmuirb92de022014-04-29 16:25:26 +00004762 DiagOpts->Warnings.push_back(ReadString(Record, Idx));
Richard Smith3be1cb22014-08-07 00:24:21 +00004763 for (unsigned N = Record[Idx++]; N; --N)
4764 DiagOpts->Remarks.push_back(ReadString(Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00004765
4766 return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
4767}
4768
4769bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
4770 ASTReaderListener &Listener) {
4771 FileSystemOptions FSOpts;
4772 unsigned Idx = 0;
4773 FSOpts.WorkingDir = ReadString(Record, Idx);
4774 return Listener.ReadFileSystemOptions(FSOpts, Complain);
4775}
4776
4777bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
4778 bool Complain,
4779 ASTReaderListener &Listener) {
4780 HeaderSearchOptions HSOpts;
4781 unsigned Idx = 0;
4782 HSOpts.Sysroot = ReadString(Record, Idx);
4783
4784 // Include entries.
4785 for (unsigned N = Record[Idx++]; N; --N) {
4786 std::string Path = ReadString(Record, Idx);
4787 frontend::IncludeDirGroup Group
4788 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
Guy Benyei11169dd2012-12-18 14:30:41 +00004789 bool IsFramework = Record[Idx++];
4790 bool IgnoreSysRoot = Record[Idx++];
Benjamin Kramer3204b152015-05-29 19:42:19 +00004791 HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
4792 IgnoreSysRoot);
Guy Benyei11169dd2012-12-18 14:30:41 +00004793 }
4794
4795 // System header prefixes.
4796 for (unsigned N = Record[Idx++]; N; --N) {
4797 std::string Prefix = ReadString(Record, Idx);
4798 bool IsSystemHeader = Record[Idx++];
Benjamin Kramer3204b152015-05-29 19:42:19 +00004799 HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
Guy Benyei11169dd2012-12-18 14:30:41 +00004800 }
4801
4802 HSOpts.ResourceDir = ReadString(Record, Idx);
4803 HSOpts.ModuleCachePath = ReadString(Record, Idx);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00004804 HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00004805 HSOpts.DisableModuleHash = Record[Idx++];
4806 HSOpts.UseBuiltinIncludes = Record[Idx++];
4807 HSOpts.UseStandardSystemIncludes = Record[Idx++];
4808 HSOpts.UseStandardCXXIncludes = Record[Idx++];
4809 HSOpts.UseLibcxx = Record[Idx++];
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004810 std::string SpecificModuleCachePath = ReadString(Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00004811
Argyrios Kyrtzidisbd0b6512015-02-19 20:12:20 +00004812 return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
4813 Complain);
Guy Benyei11169dd2012-12-18 14:30:41 +00004814}
4815
4816bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
4817 bool Complain,
4818 ASTReaderListener &Listener,
4819 std::string &SuggestedPredefines) {
4820 PreprocessorOptions PPOpts;
4821 unsigned Idx = 0;
4822
4823 // Macro definitions/undefs
4824 for (unsigned N = Record[Idx++]; N; --N) {
4825 std::string Macro = ReadString(Record, Idx);
4826 bool IsUndef = Record[Idx++];
4827 PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
4828 }
4829
4830 // Includes
4831 for (unsigned N = Record[Idx++]; N; --N) {
4832 PPOpts.Includes.push_back(ReadString(Record, Idx));
4833 }
4834
4835 // Macro Includes
4836 for (unsigned N = Record[Idx++]; N; --N) {
4837 PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
4838 }
4839
4840 PPOpts.UsePredefines = Record[Idx++];
Argyrios Kyrtzidisd3afa0c2013-04-26 21:33:40 +00004841 PPOpts.DetailedRecord = Record[Idx++];
Guy Benyei11169dd2012-12-18 14:30:41 +00004842 PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
4843 PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
4844 PPOpts.ObjCXXARCStandardLibrary =
4845 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
4846 SuggestedPredefines.clear();
4847 return Listener.ReadPreprocessorOptions(PPOpts, Complain,
4848 SuggestedPredefines);
4849}
4850
4851std::pair<ModuleFile *, unsigned>
4852ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
4853 GlobalPreprocessedEntityMapType::iterator
4854 I = GlobalPreprocessedEntityMap.find(GlobalIndex);
4855 assert(I != GlobalPreprocessedEntityMap.end() &&
4856 "Corrupted global preprocessed entity map");
4857 ModuleFile *M = I->second;
4858 unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
4859 return std::make_pair(M, LocalIndex);
4860}
4861
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00004862llvm::iterator_range<PreprocessingRecord::iterator>
Guy Benyei11169dd2012-12-18 14:30:41 +00004863ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
4864 if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
4865 return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
4866 Mod.NumPreprocessedEntities);
4867
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00004868 return llvm::make_range(PreprocessingRecord::iterator(),
4869 PreprocessingRecord::iterator());
Guy Benyei11169dd2012-12-18 14:30:41 +00004870}
4871
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00004872llvm::iterator_range<ASTReader::ModuleDeclIterator>
Guy Benyei11169dd2012-12-18 14:30:41 +00004873ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
Benjamin Kramerb4ef6682015-02-06 17:25:10 +00004874 return llvm::make_range(
4875 ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
4876 ModuleDeclIterator(this, &Mod,
4877 Mod.FileSortedDecls + Mod.NumFileSortedDecls));
Guy Benyei11169dd2012-12-18 14:30:41 +00004878}
4879
4880PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
4881 PreprocessedEntityID PPID = Index+1;
4882 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
4883 ModuleFile &M = *PPInfo.first;
4884 unsigned LocalIndex = PPInfo.second;
4885 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
4886
Guy Benyei11169dd2012-12-18 14:30:41 +00004887 if (!PP.getPreprocessingRecord()) {
4888 Error("no preprocessing record");
Craig Toppera13603a2014-05-22 05:54:18 +00004889 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00004890 }
4891
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004892 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
4893 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
4894
4895 llvm::BitstreamEntry Entry =
4896 M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
4897 if (Entry.Kind != llvm::BitstreamEntry::Record)
Craig Toppera13603a2014-05-22 05:54:18 +00004898 return nullptr;
Chris Lattner7fb3bef2013-01-20 00:56:42 +00004899
Guy Benyei11169dd2012-12-18 14:30:41 +00004900 // Read the record.
Richard Smithcb34bd32016-03-27 07:28:06 +00004901 SourceRange Range(TranslateSourceLocation(M, PPOffs.getBegin()),
4902 TranslateSourceLocation(M, PPOffs.getEnd()));
Guy Benyei11169dd2012-12-18 14:30:41 +00004903 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
Chris Lattner0e6c9402013-01-20 02:38:54 +00004904 StringRef Blob;
Guy Benyei11169dd2012-12-18 14:30:41 +00004905 RecordData Record;
4906 PreprocessorDetailRecordTypes RecType =
Chris Lattner0e6c9402013-01-20 02:38:54 +00004907 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
4908 Entry.ID, Record, &Blob);
Guy Benyei11169dd2012-12-18 14:30:41 +00004909 switch (RecType) {
4910 case PPD_MACRO_EXPANSION: {
4911 bool isBuiltin = Record[0];
Craig Toppera13603a2014-05-22 05:54:18 +00004912 IdentifierInfo *Name = nullptr;
Richard Smith66a81862015-05-04 02:25:31 +00004913 MacroDefinitionRecord *Def = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00004914 if (isBuiltin)
4915 Name = getLocalIdentifier(M, Record[1]);
4916 else {
Richard Smith66a81862015-05-04 02:25:31 +00004917 PreprocessedEntityID GlobalID =
4918 getGlobalPreprocessedEntityID(M, Record[1]);
4919 Def = cast<MacroDefinitionRecord>(
4920 PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
Guy Benyei11169dd2012-12-18 14:30:41 +00004921 }
4922
4923 MacroExpansion *ME;
4924 if (isBuiltin)
4925 ME = new (PPRec) MacroExpansion(Name, Range);
4926 else
4927 ME = new (PPRec) MacroExpansion(Def, Range);
4928
4929 return ME;
4930 }
4931
4932 case PPD_MACRO_DEFINITION: {
4933 // Decode the identifier info and then check again; if the macro is
4934 // still defined and associated with the identifier,
4935 IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
Richard Smith66a81862015-05-04 02:25:31 +00004936 MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
Guy Benyei11169dd2012-12-18 14:30:41 +00004937
4938 if (DeserializationListener)
4939 DeserializationListener->MacroDefinitionRead(PPID, MD);
4940
4941 return MD;
4942 }
4943
4944 case PPD_INCLUSION_DIRECTIVE: {
Chris Lattner0e6c9402013-01-20 02:38:54 +00004945 const char *FullFileNameStart = Blob.data() + Record[0];
4946 StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
Craig Toppera13603a2014-05-22 05:54:18 +00004947 const FileEntry *File = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00004948 if (!FullFileName.empty())
4949 File = PP.getFileManager().getFile(FullFileName);
4950
4951 // FIXME: Stable encoding
4952 InclusionDirective::InclusionKind Kind
4953 = static_cast<InclusionDirective::InclusionKind>(Record[2]);
4954 InclusionDirective *ID
4955 = new (PPRec) InclusionDirective(PPRec, Kind,
Chris Lattner0e6c9402013-01-20 02:38:54 +00004956 StringRef(Blob.data(), Record[0]),
Guy Benyei11169dd2012-12-18 14:30:41 +00004957 Record[1], Record[3],
4958 File,
4959 Range);
4960 return ID;
4961 }
4962 }
4963
4964 llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
4965}
4966
4967/// \brief \arg SLocMapI points at a chunk of a module that contains no
4968/// preprocessed entities or the entities it contains are not the ones we are
4969/// looking for. Find the next module that contains entities and return the ID
4970/// of the first entry.
4971PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
4972 GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
4973 ++SLocMapI;
4974 for (GlobalSLocOffsetMapType::const_iterator
4975 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
4976 ModuleFile &M = *SLocMapI->second;
4977 if (M.NumPreprocessedEntities)
4978 return M.BasePreprocessedEntityID;
4979 }
4980
4981 return getTotalNumPreprocessedEntities();
4982}
4983
4984namespace {
4985
Guy Benyei11169dd2012-12-18 14:30:41 +00004986struct PPEntityComp {
4987 const ASTReader &Reader;
4988 ModuleFile &M;
4989
4990 PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
4991
4992 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
4993 SourceLocation LHS = getLoc(L);
4994 SourceLocation RHS = getLoc(R);
4995 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
4996 }
4997
4998 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
4999 SourceLocation LHS = getLoc(L);
5000 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5001 }
5002
5003 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
5004 SourceLocation RHS = getLoc(R);
5005 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
5006 }
5007
5008 SourceLocation getLoc(const PPEntityOffset &PPE) const {
Richard Smithb22a1d12016-03-27 20:13:24 +00005009 return Reader.TranslateSourceLocation(M, PPE.getBegin());
Guy Benyei11169dd2012-12-18 14:30:41 +00005010 }
5011};
5012
Alexander Kornienkoab9db512015-06-22 23:07:51 +00005013}
Guy Benyei11169dd2012-12-18 14:30:41 +00005014
Alp Toker2e9ce4c2014-05-16 18:59:21 +00005015PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
5016 bool EndsAfter) const {
5017 if (SourceMgr.isLocalSourceLocation(Loc))
Guy Benyei11169dd2012-12-18 14:30:41 +00005018 return getTotalNumPreprocessedEntities();
5019
Alp Toker2e9ce4c2014-05-16 18:59:21 +00005020 GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
5021 SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
Guy Benyei11169dd2012-12-18 14:30:41 +00005022 assert(SLocMapI != GlobalSLocOffsetMap.end() &&
5023 "Corrupted global sloc offset map");
5024
5025 if (SLocMapI->second->NumPreprocessedEntities == 0)
5026 return findNextPreprocessedEntity(SLocMapI);
5027
5028 ModuleFile &M = *SLocMapI->second;
5029 typedef const PPEntityOffset *pp_iterator;
5030 pp_iterator pp_begin = M.PreprocessedEntityOffsets;
5031 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
5032
5033 size_t Count = M.NumPreprocessedEntities;
5034 size_t Half;
5035 pp_iterator First = pp_begin;
5036 pp_iterator PPI;
5037
Alp Toker2e9ce4c2014-05-16 18:59:21 +00005038 if (EndsAfter) {
5039 PPI = std::upper_bound(pp_begin, pp_end, Loc,
Richard Smithb22a1d12016-03-27 20:13:24 +00005040 PPEntityComp(*this, M));
Alp Toker2e9ce4c2014-05-16 18:59:21 +00005041 } else {
5042 // Do a binary search manually instead of using std::lower_bound because
5043 // The end locations of entities may be unordered (when a macro expansion
5044 // is inside another macro argument), but for this case it is not important
5045 // whether we get the first macro expansion or its containing macro.
5046 while (Count > 0) {
5047 Half = Count / 2;
5048 PPI = First;
5049 std::advance(PPI, Half);
Richard Smithb22a1d12016-03-27 20:13:24 +00005050 if (SourceMgr.isBeforeInTranslationUnit(
5051 TranslateSourceLocation(M, PPI->getEnd()), Loc)) {
Alp Toker2e9ce4c2014-05-16 18:59:21 +00005052 First = PPI;
5053 ++First;
5054 Count = Count - Half - 1;
5055 } else
5056 Count = Half;
5057 }
Guy Benyei11169dd2012-12-18 14:30:41 +00005058 }
5059
5060 if (PPI == pp_end)
5061 return findNextPreprocessedEntity(SLocMapI);
5062
5063 return M.BasePreprocessedEntityID + (PPI - pp_begin);
5064}
5065
Guy Benyei11169dd2012-12-18 14:30:41 +00005066/// \brief Returns a pair of [Begin, End) indices of preallocated
5067/// preprocessed entities that \arg Range encompasses.
5068std::pair<unsigned, unsigned>
5069 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
5070 if (Range.isInvalid())
5071 return std::make_pair(0,0);
5072 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
5073
Alp Toker2e9ce4c2014-05-16 18:59:21 +00005074 PreprocessedEntityID BeginID =
5075 findPreprocessedEntity(Range.getBegin(), false);
5076 PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
Guy Benyei11169dd2012-12-18 14:30:41 +00005077 return std::make_pair(BeginID, EndID);
5078}
5079
5080/// \brief Optionally returns true or false if the preallocated preprocessed
5081/// entity with index \arg Index came from file \arg FID.
David Blaikie05785d12013-02-20 22:23:23 +00005082Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
Guy Benyei11169dd2012-12-18 14:30:41 +00005083 FileID FID) {
5084 if (FID.isInvalid())
5085 return false;
5086
5087 std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
5088 ModuleFile &M = *PPInfo.first;
5089 unsigned LocalIndex = PPInfo.second;
5090 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
5091
Richard Smithcb34bd32016-03-27 07:28:06 +00005092 SourceLocation Loc = TranslateSourceLocation(M, PPOffs.getBegin());
Guy Benyei11169dd2012-12-18 14:30:41 +00005093 if (Loc.isInvalid())
5094 return false;
5095
5096 if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
5097 return true;
5098 else
5099 return false;
5100}
5101
5102namespace {
5103 /// \brief Visitor used to search for information about a header file.
5104 class HeaderFileInfoVisitor {
Guy Benyei11169dd2012-12-18 14:30:41 +00005105 const FileEntry *FE;
5106
David Blaikie05785d12013-02-20 22:23:23 +00005107 Optional<HeaderFileInfo> HFI;
Guy Benyei11169dd2012-12-18 14:30:41 +00005108
5109 public:
Argyrios Kyrtzidis61a38962013-03-06 18:12:44 +00005110 explicit HeaderFileInfoVisitor(const FileEntry *FE)
5111 : FE(FE) { }
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00005112
5113 bool operator()(ModuleFile &M) {
Guy Benyei11169dd2012-12-18 14:30:41 +00005114 HeaderFileInfoLookupTable *Table
5115 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
5116 if (!Table)
5117 return false;
5118
5119 // Look in the on-disk hash table for an entry for this file name.
Richard Smithbdf2d932015-07-30 03:37:16 +00005120 HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
Guy Benyei11169dd2012-12-18 14:30:41 +00005121 if (Pos == Table->end())
5122 return false;
5123
Richard Smithbdf2d932015-07-30 03:37:16 +00005124 HFI = *Pos;
Guy Benyei11169dd2012-12-18 14:30:41 +00005125 return true;
5126 }
5127
David Blaikie05785d12013-02-20 22:23:23 +00005128 Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
Guy Benyei11169dd2012-12-18 14:30:41 +00005129 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00005130}
Guy Benyei11169dd2012-12-18 14:30:41 +00005131
5132HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
Argyrios Kyrtzidis61a38962013-03-06 18:12:44 +00005133 HeaderFileInfoVisitor Visitor(FE);
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00005134 ModuleMgr.visit(Visitor);
Argyrios Kyrtzidis1054bbf2013-05-08 23:46:55 +00005135 if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
Guy Benyei11169dd2012-12-18 14:30:41 +00005136 return *HFI;
Guy Benyei11169dd2012-12-18 14:30:41 +00005137
5138 return HeaderFileInfo();
5139}
5140
5141void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
5142 // FIXME: Make it work properly with modules.
Dmitri Gribenkof8579502013-01-12 19:30:44 +00005143 SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
Guy Benyei11169dd2012-12-18 14:30:41 +00005144 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
5145 ModuleFile &F = *(*I);
5146 unsigned Idx = 0;
5147 DiagStates.clear();
5148 assert(!Diag.DiagStates.empty());
5149 DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
5150 while (Idx < F.PragmaDiagMappings.size()) {
5151 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
5152 unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
5153 if (DiagStateID != 0) {
5154 Diag.DiagStatePoints.push_back(
5155 DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
5156 FullSourceLoc(Loc, SourceMgr)));
5157 continue;
5158 }
5159
5160 assert(DiagStateID == 0);
5161 // A new DiagState was created here.
5162 Diag.DiagStates.push_back(*Diag.GetCurDiagState());
5163 DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
5164 DiagStates.push_back(NewState);
5165 Diag.DiagStatePoints.push_back(
5166 DiagnosticsEngine::DiagStatePoint(NewState,
5167 FullSourceLoc(Loc, SourceMgr)));
5168 while (1) {
5169 assert(Idx < F.PragmaDiagMappings.size() &&
5170 "Invalid data, didn't find '-1' marking end of diag/map pairs");
5171 if (Idx >= F.PragmaDiagMappings.size()) {
5172 break; // Something is messed up but at least avoid infinite loop in
5173 // release build.
5174 }
5175 unsigned DiagID = F.PragmaDiagMappings[Idx++];
5176 if (DiagID == (unsigned)-1) {
5177 break; // no more diag/map pairs for this location.
5178 }
Alp Tokerc726c362014-06-10 09:31:37 +00005179 diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
5180 DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
5181 Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
Guy Benyei11169dd2012-12-18 14:30:41 +00005182 }
5183 }
5184 }
5185}
5186
5187/// \brief Get the correct cursor and offset for loading a type.
5188ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
5189 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
5190 assert(I != GlobalTypeMap.end() && "Corrupted global type map");
5191 ModuleFile *M = I->second;
5192 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
5193}
5194
5195/// \brief Read and return the type with the given index..
5196///
5197/// The index is the type ID, shifted and minus the number of predefs. This
5198/// routine actually reads the record corresponding to the type at the given
5199/// location. It is a helper routine for GetType, which deals with reading type
5200/// IDs.
5201QualType ASTReader::readTypeRecord(unsigned Index) {
5202 RecordLocation Loc = TypeCursorForIndex(Index);
Chris Lattner7fb3bef2013-01-20 00:56:42 +00005203 BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00005204
5205 // Keep track of where we are in the stream, then jump back there
5206 // after reading this type.
5207 SavedStreamPosition SavedPosition(DeclsCursor);
5208
5209 ReadingKindTracker ReadingKind(Read_Type, *this);
5210
5211 // Note that we are loading a type record.
5212 Deserializing AType(this);
5213
5214 unsigned Idx = 0;
5215 DeclsCursor.JumpToBit(Loc.Offset);
5216 RecordData Record;
5217 unsigned Code = DeclsCursor.ReadCode();
Chris Lattner0e6c9402013-01-20 02:38:54 +00005218 switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00005219 case TYPE_EXT_QUAL: {
5220 if (Record.size() != 2) {
5221 Error("Incorrect encoding of extended qualifier type");
5222 return QualType();
5223 }
5224 QualType Base = readType(*Loc.F, Record, Idx);
5225 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
5226 return Context.getQualifiedType(Base, Quals);
5227 }
5228
5229 case TYPE_COMPLEX: {
5230 if (Record.size() != 1) {
5231 Error("Incorrect encoding of complex type");
5232 return QualType();
5233 }
5234 QualType ElemType = readType(*Loc.F, Record, Idx);
5235 return Context.getComplexType(ElemType);
5236 }
5237
5238 case TYPE_POINTER: {
5239 if (Record.size() != 1) {
5240 Error("Incorrect encoding of pointer type");
5241 return QualType();
5242 }
5243 QualType PointeeType = readType(*Loc.F, Record, Idx);
5244 return Context.getPointerType(PointeeType);
5245 }
5246
Reid Kleckner8a365022013-06-24 17:51:48 +00005247 case TYPE_DECAYED: {
5248 if (Record.size() != 1) {
5249 Error("Incorrect encoding of decayed type");
5250 return QualType();
5251 }
5252 QualType OriginalType = readType(*Loc.F, Record, Idx);
5253 QualType DT = Context.getAdjustedParameterType(OriginalType);
5254 if (!isa<DecayedType>(DT))
5255 Error("Decayed type does not decay");
5256 return DT;
5257 }
5258
Reid Kleckner0503a872013-12-05 01:23:43 +00005259 case TYPE_ADJUSTED: {
5260 if (Record.size() != 2) {
5261 Error("Incorrect encoding of adjusted type");
5262 return QualType();
5263 }
5264 QualType OriginalTy = readType(*Loc.F, Record, Idx);
5265 QualType AdjustedTy = readType(*Loc.F, Record, Idx);
5266 return Context.getAdjustedType(OriginalTy, AdjustedTy);
5267 }
5268
Guy Benyei11169dd2012-12-18 14:30:41 +00005269 case TYPE_BLOCK_POINTER: {
5270 if (Record.size() != 1) {
5271 Error("Incorrect encoding of block pointer type");
5272 return QualType();
5273 }
5274 QualType PointeeType = readType(*Loc.F, Record, Idx);
5275 return Context.getBlockPointerType(PointeeType);
5276 }
5277
5278 case TYPE_LVALUE_REFERENCE: {
5279 if (Record.size() != 2) {
5280 Error("Incorrect encoding of lvalue reference type");
5281 return QualType();
5282 }
5283 QualType PointeeType = readType(*Loc.F, Record, Idx);
5284 return Context.getLValueReferenceType(PointeeType, Record[1]);
5285 }
5286
5287 case TYPE_RVALUE_REFERENCE: {
5288 if (Record.size() != 1) {
5289 Error("Incorrect encoding of rvalue reference type");
5290 return QualType();
5291 }
5292 QualType PointeeType = readType(*Loc.F, Record, Idx);
5293 return Context.getRValueReferenceType(PointeeType);
5294 }
5295
5296 case TYPE_MEMBER_POINTER: {
5297 if (Record.size() != 2) {
5298 Error("Incorrect encoding of member pointer type");
5299 return QualType();
5300 }
5301 QualType PointeeType = readType(*Loc.F, Record, Idx);
5302 QualType ClassType = readType(*Loc.F, Record, Idx);
5303 if (PointeeType.isNull() || ClassType.isNull())
5304 return QualType();
5305
5306 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
5307 }
5308
5309 case TYPE_CONSTANT_ARRAY: {
5310 QualType ElementType = readType(*Loc.F, Record, Idx);
5311 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5312 unsigned IndexTypeQuals = Record[2];
5313 unsigned Idx = 3;
5314 llvm::APInt Size = ReadAPInt(Record, Idx);
5315 return Context.getConstantArrayType(ElementType, Size,
5316 ASM, IndexTypeQuals);
5317 }
5318
5319 case TYPE_INCOMPLETE_ARRAY: {
5320 QualType ElementType = readType(*Loc.F, Record, Idx);
5321 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5322 unsigned IndexTypeQuals = Record[2];
5323 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
5324 }
5325
5326 case TYPE_VARIABLE_ARRAY: {
5327 QualType ElementType = readType(*Loc.F, Record, Idx);
5328 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
5329 unsigned IndexTypeQuals = Record[2];
5330 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
5331 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
5332 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
5333 ASM, IndexTypeQuals,
5334 SourceRange(LBLoc, RBLoc));
5335 }
5336
5337 case TYPE_VECTOR: {
5338 if (Record.size() != 3) {
5339 Error("incorrect encoding of vector type in AST file");
5340 return QualType();
5341 }
5342
5343 QualType ElementType = readType(*Loc.F, Record, Idx);
5344 unsigned NumElements = Record[1];
5345 unsigned VecKind = Record[2];
5346 return Context.getVectorType(ElementType, NumElements,
5347 (VectorType::VectorKind)VecKind);
5348 }
5349
5350 case TYPE_EXT_VECTOR: {
5351 if (Record.size() != 3) {
5352 Error("incorrect encoding of extended vector type in AST file");
5353 return QualType();
5354 }
5355
5356 QualType ElementType = readType(*Loc.F, Record, Idx);
5357 unsigned NumElements = Record[1];
5358 return Context.getExtVectorType(ElementType, NumElements);
5359 }
5360
5361 case TYPE_FUNCTION_NO_PROTO: {
5362 if (Record.size() != 6) {
5363 Error("incorrect encoding of no-proto function type");
5364 return QualType();
5365 }
5366 QualType ResultType = readType(*Loc.F, Record, Idx);
5367 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
5368 (CallingConv)Record[4], Record[5]);
5369 return Context.getFunctionNoProtoType(ResultType, Info);
5370 }
5371
5372 case TYPE_FUNCTION_PROTO: {
5373 QualType ResultType = readType(*Loc.F, Record, Idx);
5374
5375 FunctionProtoType::ExtProtoInfo EPI;
5376 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
5377 /*hasregparm*/ Record[2],
5378 /*regparm*/ Record[3],
5379 static_cast<CallingConv>(Record[4]),
5380 /*produces*/ Record[5]);
5381
5382 unsigned Idx = 6;
Guy Benyei11169dd2012-12-18 14:30:41 +00005383
5384 EPI.Variadic = Record[Idx++];
5385 EPI.HasTrailingReturn = Record[Idx++];
5386 EPI.TypeQuals = Record[Idx++];
5387 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
Richard Smith564417a2014-03-20 21:47:22 +00005388 SmallVector<QualType, 8> ExceptionStorage;
Richard Smith8acb4282014-07-31 21:57:55 +00005389 readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
Richard Smith01b2cb42014-07-26 06:37:51 +00005390
5391 unsigned NumParams = Record[Idx++];
5392 SmallVector<QualType, 16> ParamTypes;
5393 for (unsigned I = 0; I != NumParams; ++I)
5394 ParamTypes.push_back(readType(*Loc.F, Record, Idx));
5395
John McCall18afab72016-03-01 00:49:02 +00005396 SmallVector<FunctionProtoType::ExtParameterInfo, 4> ExtParameterInfos;
5397 if (Idx != Record.size()) {
5398 for (unsigned I = 0; I != NumParams; ++I)
5399 ExtParameterInfos.push_back(
5400 FunctionProtoType::ExtParameterInfo
5401 ::getFromOpaqueValue(Record[Idx++]));
5402 EPI.ExtParameterInfos = ExtParameterInfos.data();
5403 }
5404
5405 assert(Idx == Record.size());
5406
Jordan Rose5c382722013-03-08 21:51:21 +00005407 return Context.getFunctionType(ResultType, ParamTypes, EPI);
Guy Benyei11169dd2012-12-18 14:30:41 +00005408 }
5409
5410 case TYPE_UNRESOLVED_USING: {
5411 unsigned Idx = 0;
5412 return Context.getTypeDeclType(
5413 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
5414 }
5415
5416 case TYPE_TYPEDEF: {
5417 if (Record.size() != 2) {
5418 Error("incorrect encoding of typedef type");
5419 return QualType();
5420 }
5421 unsigned Idx = 0;
5422 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
5423 QualType Canonical = readType(*Loc.F, Record, Idx);
5424 if (!Canonical.isNull())
5425 Canonical = Context.getCanonicalType(Canonical);
5426 return Context.getTypedefType(Decl, Canonical);
5427 }
5428
5429 case TYPE_TYPEOF_EXPR:
5430 return Context.getTypeOfExprType(ReadExpr(*Loc.F));
5431
5432 case TYPE_TYPEOF: {
5433 if (Record.size() != 1) {
5434 Error("incorrect encoding of typeof(type) in AST file");
5435 return QualType();
5436 }
5437 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5438 return Context.getTypeOfType(UnderlyingType);
5439 }
5440
5441 case TYPE_DECLTYPE: {
5442 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5443 return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
5444 }
5445
5446 case TYPE_UNARY_TRANSFORM: {
5447 QualType BaseType = readType(*Loc.F, Record, Idx);
5448 QualType UnderlyingType = readType(*Loc.F, Record, Idx);
5449 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
5450 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
5451 }
5452
Richard Smith74aeef52013-04-26 16:15:35 +00005453 case TYPE_AUTO: {
5454 QualType Deduced = readType(*Loc.F, Record, Idx);
Richard Smithe301ba22015-11-11 02:02:15 +00005455 AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
Richard Smith27d807c2013-04-30 13:56:41 +00005456 bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
Richard Smithe301ba22015-11-11 02:02:15 +00005457 return Context.getAutoType(Deduced, Keyword, IsDependent);
Richard Smith74aeef52013-04-26 16:15:35 +00005458 }
Guy Benyei11169dd2012-12-18 14:30:41 +00005459
5460 case TYPE_RECORD: {
5461 if (Record.size() != 2) {
5462 Error("incorrect encoding of record type");
5463 return QualType();
5464 }
5465 unsigned Idx = 0;
5466 bool IsDependent = Record[Idx++];
5467 RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
5468 RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
5469 QualType T = Context.getRecordType(RD);
5470 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5471 return T;
5472 }
5473
5474 case TYPE_ENUM: {
5475 if (Record.size() != 2) {
5476 Error("incorrect encoding of enum type");
5477 return QualType();
5478 }
5479 unsigned Idx = 0;
5480 bool IsDependent = Record[Idx++];
5481 QualType T
5482 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
5483 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5484 return T;
5485 }
5486
5487 case TYPE_ATTRIBUTED: {
5488 if (Record.size() != 3) {
5489 Error("incorrect encoding of attributed type");
5490 return QualType();
5491 }
5492 QualType modifiedType = readType(*Loc.F, Record, Idx);
5493 QualType equivalentType = readType(*Loc.F, Record, Idx);
5494 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
5495 return Context.getAttributedType(kind, modifiedType, equivalentType);
5496 }
5497
5498 case TYPE_PAREN: {
5499 if (Record.size() != 1) {
5500 Error("incorrect encoding of paren type");
5501 return QualType();
5502 }
5503 QualType InnerType = readType(*Loc.F, Record, Idx);
5504 return Context.getParenType(InnerType);
5505 }
5506
5507 case TYPE_PACK_EXPANSION: {
5508 if (Record.size() != 2) {
5509 Error("incorrect encoding of pack expansion type");
5510 return QualType();
5511 }
5512 QualType Pattern = readType(*Loc.F, Record, Idx);
5513 if (Pattern.isNull())
5514 return QualType();
David Blaikie05785d12013-02-20 22:23:23 +00005515 Optional<unsigned> NumExpansions;
Guy Benyei11169dd2012-12-18 14:30:41 +00005516 if (Record[1])
5517 NumExpansions = Record[1] - 1;
5518 return Context.getPackExpansionType(Pattern, NumExpansions);
5519 }
5520
5521 case TYPE_ELABORATED: {
5522 unsigned Idx = 0;
5523 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5524 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
5525 QualType NamedType = readType(*Loc.F, Record, Idx);
5526 return Context.getElaboratedType(Keyword, NNS, NamedType);
5527 }
5528
5529 case TYPE_OBJC_INTERFACE: {
5530 unsigned Idx = 0;
5531 ObjCInterfaceDecl *ItfD
5532 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
5533 return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
5534 }
5535
5536 case TYPE_OBJC_OBJECT: {
5537 unsigned Idx = 0;
5538 QualType Base = readType(*Loc.F, Record, Idx);
Douglas Gregore9d95f12015-07-07 03:57:35 +00005539 unsigned NumTypeArgs = Record[Idx++];
5540 SmallVector<QualType, 4> TypeArgs;
5541 for (unsigned I = 0; I != NumTypeArgs; ++I)
5542 TypeArgs.push_back(readType(*Loc.F, Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00005543 unsigned NumProtos = Record[Idx++];
5544 SmallVector<ObjCProtocolDecl*, 4> Protos;
5545 for (unsigned I = 0; I != NumProtos; ++I)
5546 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
Douglas Gregorab209d82015-07-07 03:58:42 +00005547 bool IsKindOf = Record[Idx++];
5548 return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
Guy Benyei11169dd2012-12-18 14:30:41 +00005549 }
5550
5551 case TYPE_OBJC_OBJECT_POINTER: {
5552 unsigned Idx = 0;
5553 QualType Pointee = readType(*Loc.F, Record, Idx);
5554 return Context.getObjCObjectPointerType(Pointee);
5555 }
5556
5557 case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
5558 unsigned Idx = 0;
5559 QualType Parm = readType(*Loc.F, Record, Idx);
5560 QualType Replacement = readType(*Loc.F, Record, Idx);
Stephan Tolksdorfe96f8b32014-03-15 10:23:27 +00005561 return Context.getSubstTemplateTypeParmType(
5562 cast<TemplateTypeParmType>(Parm),
5563 Context.getCanonicalType(Replacement));
Guy Benyei11169dd2012-12-18 14:30:41 +00005564 }
5565
5566 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
5567 unsigned Idx = 0;
5568 QualType Parm = readType(*Loc.F, Record, Idx);
5569 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
5570 return Context.getSubstTemplateTypeParmPackType(
5571 cast<TemplateTypeParmType>(Parm),
5572 ArgPack);
5573 }
5574
5575 case TYPE_INJECTED_CLASS_NAME: {
5576 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
5577 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
5578 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable
5579 // for AST reading, too much interdependencies.
Richard Smith6377f8f2014-10-21 21:15:18 +00005580 const Type *T = nullptr;
5581 for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
5582 if (const Type *Existing = DI->getTypeForDecl()) {
5583 T = Existing;
5584 break;
5585 }
5586 }
5587 if (!T) {
Richard Smithf17fdbd2014-04-24 02:25:27 +00005588 T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
Richard Smith6377f8f2014-10-21 21:15:18 +00005589 for (auto *DI = D; DI; DI = DI->getPreviousDecl())
5590 DI->setTypeForDecl(T);
5591 }
Richard Smithf17fdbd2014-04-24 02:25:27 +00005592 return QualType(T, 0);
Guy Benyei11169dd2012-12-18 14:30:41 +00005593 }
5594
5595 case TYPE_TEMPLATE_TYPE_PARM: {
5596 unsigned Idx = 0;
5597 unsigned Depth = Record[Idx++];
5598 unsigned Index = Record[Idx++];
5599 bool Pack = Record[Idx++];
5600 TemplateTypeParmDecl *D
5601 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
5602 return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
5603 }
5604
5605 case TYPE_DEPENDENT_NAME: {
5606 unsigned Idx = 0;
5607 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5608 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Richard Smithbdf2d932015-07-30 03:37:16 +00005609 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00005610 QualType Canon = readType(*Loc.F, Record, Idx);
5611 if (!Canon.isNull())
5612 Canon = Context.getCanonicalType(Canon);
5613 return Context.getDependentNameType(Keyword, NNS, Name, Canon);
5614 }
5615
5616 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
5617 unsigned Idx = 0;
5618 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
5619 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Richard Smithbdf2d932015-07-30 03:37:16 +00005620 const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00005621 unsigned NumArgs = Record[Idx++];
5622 SmallVector<TemplateArgument, 8> Args;
5623 Args.reserve(NumArgs);
5624 while (NumArgs--)
5625 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
5626 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
5627 Args.size(), Args.data());
5628 }
5629
5630 case TYPE_DEPENDENT_SIZED_ARRAY: {
5631 unsigned Idx = 0;
5632
5633 // ArrayType
5634 QualType ElementType = readType(*Loc.F, Record, Idx);
5635 ArrayType::ArraySizeModifier ASM
5636 = (ArrayType::ArraySizeModifier)Record[Idx++];
5637 unsigned IndexTypeQuals = Record[Idx++];
5638
5639 // DependentSizedArrayType
5640 Expr *NumElts = ReadExpr(*Loc.F);
5641 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
5642
5643 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
5644 IndexTypeQuals, Brackets);
5645 }
5646
5647 case TYPE_TEMPLATE_SPECIALIZATION: {
5648 unsigned Idx = 0;
5649 bool IsDependent = Record[Idx++];
5650 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
5651 SmallVector<TemplateArgument, 8> Args;
5652 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
5653 QualType Underlying = readType(*Loc.F, Record, Idx);
5654 QualType T;
5655 if (Underlying.isNull())
5656 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
5657 Args.size());
5658 else
5659 T = Context.getTemplateSpecializationType(Name, Args.data(),
5660 Args.size(), Underlying);
5661 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
5662 return T;
5663 }
5664
5665 case TYPE_ATOMIC: {
5666 if (Record.size() != 1) {
5667 Error("Incorrect encoding of atomic type");
5668 return QualType();
5669 }
5670 QualType ValueType = readType(*Loc.F, Record, Idx);
5671 return Context.getAtomicType(ValueType);
5672 }
Xiuli Pan9c14e282016-01-09 12:53:17 +00005673
5674 case TYPE_PIPE: {
5675 if (Record.size() != 1) {
5676 Error("Incorrect encoding of pipe type");
5677 return QualType();
5678 }
5679
5680 // Reading the pipe element type.
5681 QualType ElementType = readType(*Loc.F, Record, Idx);
5682 return Context.getPipeType(ElementType);
5683 }
Guy Benyei11169dd2012-12-18 14:30:41 +00005684 }
5685 llvm_unreachable("Invalid TypeCode!");
5686}
5687
Richard Smith564417a2014-03-20 21:47:22 +00005688void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
5689 SmallVectorImpl<QualType> &Exceptions,
Richard Smith8acb4282014-07-31 21:57:55 +00005690 FunctionProtoType::ExceptionSpecInfo &ESI,
Richard Smith564417a2014-03-20 21:47:22 +00005691 const RecordData &Record, unsigned &Idx) {
5692 ExceptionSpecificationType EST =
5693 static_cast<ExceptionSpecificationType>(Record[Idx++]);
Richard Smith8acb4282014-07-31 21:57:55 +00005694 ESI.Type = EST;
Richard Smith564417a2014-03-20 21:47:22 +00005695 if (EST == EST_Dynamic) {
Richard Smith8acb4282014-07-31 21:57:55 +00005696 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
Richard Smith564417a2014-03-20 21:47:22 +00005697 Exceptions.push_back(readType(ModuleFile, Record, Idx));
Richard Smith8acb4282014-07-31 21:57:55 +00005698 ESI.Exceptions = Exceptions;
Richard Smith564417a2014-03-20 21:47:22 +00005699 } else if (EST == EST_ComputedNoexcept) {
Richard Smith8acb4282014-07-31 21:57:55 +00005700 ESI.NoexceptExpr = ReadExpr(ModuleFile);
Richard Smith564417a2014-03-20 21:47:22 +00005701 } else if (EST == EST_Uninstantiated) {
Richard Smith8acb4282014-07-31 21:57:55 +00005702 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
5703 ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
Richard Smith564417a2014-03-20 21:47:22 +00005704 } else if (EST == EST_Unevaluated) {
Richard Smith8acb4282014-07-31 21:57:55 +00005705 ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
Richard Smith564417a2014-03-20 21:47:22 +00005706 }
5707}
5708
Guy Benyei11169dd2012-12-18 14:30:41 +00005709class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
5710 ASTReader &Reader;
5711 ModuleFile &F;
5712 const ASTReader::RecordData &Record;
5713 unsigned &Idx;
5714
5715 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
5716 unsigned &I) {
5717 return Reader.ReadSourceLocation(F, R, I);
5718 }
5719
5720 template<typename T>
5721 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
5722 return Reader.ReadDeclAs<T>(F, Record, Idx);
5723 }
5724
5725public:
5726 TypeLocReader(ASTReader &Reader, ModuleFile &F,
5727 const ASTReader::RecordData &Record, unsigned &Idx)
5728 : Reader(Reader), F(F), Record(Record), Idx(Idx)
5729 { }
5730
5731 // We want compile-time assurance that we've enumerated all of
5732 // these, so unfortunately we have to declare them first, then
5733 // define them out-of-line.
5734#define ABSTRACT_TYPELOC(CLASS, PARENT)
5735#define TYPELOC(CLASS, PARENT) \
5736 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
5737#include "clang/AST/TypeLocNodes.def"
5738
5739 void VisitFunctionTypeLoc(FunctionTypeLoc);
5740 void VisitArrayTypeLoc(ArrayTypeLoc);
5741};
5742
5743void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
5744 // nothing to do
5745}
5746void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
5747 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx));
5748 if (TL.needsExtraLocalData()) {
5749 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
5750 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
5751 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
5752 TL.setModeAttr(Record[Idx++]);
5753 }
5754}
5755void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
5756 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5757}
5758void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
5759 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5760}
Reid Kleckner8a365022013-06-24 17:51:48 +00005761void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
5762 // nothing to do
5763}
Reid Kleckner0503a872013-12-05 01:23:43 +00005764void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
5765 // nothing to do
5766}
Guy Benyei11169dd2012-12-18 14:30:41 +00005767void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
5768 TL.setCaretLoc(ReadSourceLocation(Record, Idx));
5769}
5770void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
5771 TL.setAmpLoc(ReadSourceLocation(Record, Idx));
5772}
5773void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
5774 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
5775}
5776void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
5777 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5778 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5779}
5780void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
5781 TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
5782 TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
5783 if (Record[Idx++])
5784 TL.setSizeExpr(Reader.ReadExpr(F));
5785 else
Craig Toppera13603a2014-05-22 05:54:18 +00005786 TL.setSizeExpr(nullptr);
Guy Benyei11169dd2012-12-18 14:30:41 +00005787}
5788void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
5789 VisitArrayTypeLoc(TL);
5790}
5791void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
5792 VisitArrayTypeLoc(TL);
5793}
5794void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
5795 VisitArrayTypeLoc(TL);
5796}
5797void TypeLocReader::VisitDependentSizedArrayTypeLoc(
5798 DependentSizedArrayTypeLoc TL) {
5799 VisitArrayTypeLoc(TL);
5800}
5801void TypeLocReader::VisitDependentSizedExtVectorTypeLoc(
5802 DependentSizedExtVectorTypeLoc TL) {
5803 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5804}
5805void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
5806 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5807}
5808void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
5809 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5810}
5811void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
5812 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
5813 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5814 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5815 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
Alp Tokerb3fd5cf2014-01-21 00:32:38 +00005816 for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
5817 TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00005818 }
5819}
5820void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
5821 VisitFunctionTypeLoc(TL);
5822}
5823void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
5824 VisitFunctionTypeLoc(TL);
5825}
5826void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
5827 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5828}
5829void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
5830 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5831}
5832void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
5833 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5834 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5835 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5836}
5837void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
5838 TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
5839 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5840 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5841 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5842}
5843void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
5844 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5845}
5846void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
5847 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5848 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5849 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5850 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
5851}
5852void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
5853 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5854}
5855void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
5856 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5857}
5858void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
5859 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5860}
5861void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
5862 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
5863 if (TL.hasAttrOperand()) {
5864 SourceRange range;
5865 range.setBegin(ReadSourceLocation(Record, Idx));
5866 range.setEnd(ReadSourceLocation(Record, Idx));
5867 TL.setAttrOperandParensRange(range);
5868 }
5869 if (TL.hasAttrExprOperand()) {
5870 if (Record[Idx++])
5871 TL.setAttrExprOperand(Reader.ReadExpr(F));
5872 else
Craig Toppera13603a2014-05-22 05:54:18 +00005873 TL.setAttrExprOperand(nullptr);
Guy Benyei11169dd2012-12-18 14:30:41 +00005874 } else if (TL.hasAttrEnumOperand())
5875 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
5876}
5877void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
5878 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5879}
5880void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
5881 SubstTemplateTypeParmTypeLoc TL) {
5882 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5883}
5884void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
5885 SubstTemplateTypeParmPackTypeLoc TL) {
5886 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5887}
5888void TypeLocReader::VisitTemplateSpecializationTypeLoc(
5889 TemplateSpecializationTypeLoc TL) {
5890 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5891 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5892 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5893 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5894 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
5895 TL.setArgLocInfo(i,
5896 Reader.GetTemplateArgumentLocInfo(F,
5897 TL.getTypePtr()->getArg(i).getKind(),
5898 Record, Idx));
5899}
5900void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
5901 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5902 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5903}
5904void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
5905 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5906 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5907}
5908void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
5909 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5910}
5911void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
5912 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5913 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5914 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5915}
5916void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
5917 DependentTemplateSpecializationTypeLoc TL) {
5918 TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
5919 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
5920 TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
5921 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
5922 TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
5923 TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
5924 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
5925 TL.setArgLocInfo(I,
5926 Reader.GetTemplateArgumentLocInfo(F,
5927 TL.getTypePtr()->getArg(I).getKind(),
5928 Record, Idx));
5929}
5930void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
5931 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
5932}
5933void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
5934 TL.setNameLoc(ReadSourceLocation(Record, Idx));
5935}
5936void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
5937 TL.setHasBaseTypeAsWritten(Record[Idx++]);
Douglas Gregore9d95f12015-07-07 03:57:35 +00005938 TL.setTypeArgsLAngleLoc(ReadSourceLocation(Record, Idx));
5939 TL.setTypeArgsRAngleLoc(ReadSourceLocation(Record, Idx));
5940 for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
5941 TL.setTypeArgTInfo(i, Reader.GetTypeSourceInfo(F, Record, Idx));
5942 TL.setProtocolLAngleLoc(ReadSourceLocation(Record, Idx));
5943 TL.setProtocolRAngleLoc(ReadSourceLocation(Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00005944 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
5945 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
5946}
5947void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
5948 TL.setStarLoc(ReadSourceLocation(Record, Idx));
5949}
5950void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
5951 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5952 TL.setLParenLoc(ReadSourceLocation(Record, Idx));
5953 TL.setRParenLoc(ReadSourceLocation(Record, Idx));
5954}
Xiuli Pan9c14e282016-01-09 12:53:17 +00005955void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
5956 TL.setKWLoc(ReadSourceLocation(Record, Idx));
5957}
Guy Benyei11169dd2012-12-18 14:30:41 +00005958
5959TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
5960 const RecordData &Record,
5961 unsigned &Idx) {
5962 QualType InfoTy = readType(F, Record, Idx);
5963 if (InfoTy.isNull())
Craig Toppera13603a2014-05-22 05:54:18 +00005964 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00005965
5966 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
5967 TypeLocReader TLR(*this, F, Record, Idx);
5968 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
5969 TLR.Visit(TL);
5970 return TInfo;
5971}
5972
5973QualType ASTReader::GetType(TypeID ID) {
5974 unsigned FastQuals = ID & Qualifiers::FastMask;
5975 unsigned Index = ID >> Qualifiers::FastWidth;
5976
5977 if (Index < NUM_PREDEF_TYPE_IDS) {
5978 QualType T;
5979 switch ((PredefinedTypeIDs)Index) {
Alexey Baderbdf7c842015-09-15 12:18:29 +00005980 case PREDEF_TYPE_NULL_ID:
5981 return QualType();
5982 case PREDEF_TYPE_VOID_ID:
5983 T = Context.VoidTy;
5984 break;
5985 case PREDEF_TYPE_BOOL_ID:
5986 T = Context.BoolTy;
5987 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00005988
5989 case PREDEF_TYPE_CHAR_U_ID:
5990 case PREDEF_TYPE_CHAR_S_ID:
5991 // FIXME: Check that the signedness of CharTy is correct!
5992 T = Context.CharTy;
5993 break;
5994
Alexey Baderbdf7c842015-09-15 12:18:29 +00005995 case PREDEF_TYPE_UCHAR_ID:
5996 T = Context.UnsignedCharTy;
5997 break;
5998 case PREDEF_TYPE_USHORT_ID:
5999 T = Context.UnsignedShortTy;
6000 break;
6001 case PREDEF_TYPE_UINT_ID:
6002 T = Context.UnsignedIntTy;
6003 break;
6004 case PREDEF_TYPE_ULONG_ID:
6005 T = Context.UnsignedLongTy;
6006 break;
6007 case PREDEF_TYPE_ULONGLONG_ID:
6008 T = Context.UnsignedLongLongTy;
6009 break;
6010 case PREDEF_TYPE_UINT128_ID:
6011 T = Context.UnsignedInt128Ty;
6012 break;
6013 case PREDEF_TYPE_SCHAR_ID:
6014 T = Context.SignedCharTy;
6015 break;
6016 case PREDEF_TYPE_WCHAR_ID:
6017 T = Context.WCharTy;
6018 break;
6019 case PREDEF_TYPE_SHORT_ID:
6020 T = Context.ShortTy;
6021 break;
6022 case PREDEF_TYPE_INT_ID:
6023 T = Context.IntTy;
6024 break;
6025 case PREDEF_TYPE_LONG_ID:
6026 T = Context.LongTy;
6027 break;
6028 case PREDEF_TYPE_LONGLONG_ID:
6029 T = Context.LongLongTy;
6030 break;
6031 case PREDEF_TYPE_INT128_ID:
6032 T = Context.Int128Ty;
6033 break;
6034 case PREDEF_TYPE_HALF_ID:
6035 T = Context.HalfTy;
6036 break;
6037 case PREDEF_TYPE_FLOAT_ID:
6038 T = Context.FloatTy;
6039 break;
6040 case PREDEF_TYPE_DOUBLE_ID:
6041 T = Context.DoubleTy;
6042 break;
6043 case PREDEF_TYPE_LONGDOUBLE_ID:
6044 T = Context.LongDoubleTy;
6045 break;
6046 case PREDEF_TYPE_OVERLOAD_ID:
6047 T = Context.OverloadTy;
6048 break;
6049 case PREDEF_TYPE_BOUND_MEMBER:
6050 T = Context.BoundMemberTy;
6051 break;
6052 case PREDEF_TYPE_PSEUDO_OBJECT:
6053 T = Context.PseudoObjectTy;
6054 break;
6055 case PREDEF_TYPE_DEPENDENT_ID:
6056 T = Context.DependentTy;
6057 break;
6058 case PREDEF_TYPE_UNKNOWN_ANY:
6059 T = Context.UnknownAnyTy;
6060 break;
6061 case PREDEF_TYPE_NULLPTR_ID:
6062 T = Context.NullPtrTy;
6063 break;
6064 case PREDEF_TYPE_CHAR16_ID:
6065 T = Context.Char16Ty;
6066 break;
6067 case PREDEF_TYPE_CHAR32_ID:
6068 T = Context.Char32Ty;
6069 break;
6070 case PREDEF_TYPE_OBJC_ID:
6071 T = Context.ObjCBuiltinIdTy;
6072 break;
6073 case PREDEF_TYPE_OBJC_CLASS:
6074 T = Context.ObjCBuiltinClassTy;
6075 break;
6076 case PREDEF_TYPE_OBJC_SEL:
6077 T = Context.ObjCBuiltinSelTy;
6078 break;
6079 case PREDEF_TYPE_IMAGE1D_ID:
6080 T = Context.OCLImage1dTy;
6081 break;
6082 case PREDEF_TYPE_IMAGE1D_ARR_ID:
6083 T = Context.OCLImage1dArrayTy;
6084 break;
6085 case PREDEF_TYPE_IMAGE1D_BUFF_ID:
6086 T = Context.OCLImage1dBufferTy;
6087 break;
6088 case PREDEF_TYPE_IMAGE2D_ID:
6089 T = Context.OCLImage2dTy;
6090 break;
6091 case PREDEF_TYPE_IMAGE2D_ARR_ID:
6092 T = Context.OCLImage2dArrayTy;
6093 break;
Alexey Bader9c8453f2015-09-15 11:18:52 +00006094 case PREDEF_TYPE_IMAGE2D_DEP_ID:
6095 T = Context.OCLImage2dDepthTy;
6096 break;
6097 case PREDEF_TYPE_IMAGE2D_ARR_DEP_ID:
6098 T = Context.OCLImage2dArrayDepthTy;
6099 break;
6100 case PREDEF_TYPE_IMAGE2D_MSAA_ID:
6101 T = Context.OCLImage2dMSAATy;
6102 break;
6103 case PREDEF_TYPE_IMAGE2D_ARR_MSAA_ID:
6104 T = Context.OCLImage2dArrayMSAATy;
6105 break;
6106 case PREDEF_TYPE_IMAGE2D_MSAA_DEP_ID:
6107 T = Context.OCLImage2dMSAADepthTy;
6108 break;
6109 case PREDEF_TYPE_IMAGE2D_ARR_MSAA_DEPTH_ID:
6110 T = Context.OCLImage2dArrayMSAADepthTy;
6111 break;
Alexey Baderbdf7c842015-09-15 12:18:29 +00006112 case PREDEF_TYPE_IMAGE3D_ID:
6113 T = Context.OCLImage3dTy;
6114 break;
6115 case PREDEF_TYPE_SAMPLER_ID:
6116 T = Context.OCLSamplerTy;
6117 break;
6118 case PREDEF_TYPE_EVENT_ID:
6119 T = Context.OCLEventTy;
6120 break;
Alexey Bader9c8453f2015-09-15 11:18:52 +00006121 case PREDEF_TYPE_CLK_EVENT_ID:
6122 T = Context.OCLClkEventTy;
6123 break;
6124 case PREDEF_TYPE_QUEUE_ID:
6125 T = Context.OCLQueueTy;
6126 break;
6127 case PREDEF_TYPE_NDRANGE_ID:
6128 T = Context.OCLNDRangeTy;
6129 break;
6130 case PREDEF_TYPE_RESERVE_ID_ID:
6131 T = Context.OCLReserveIDTy;
6132 break;
Alexey Baderbdf7c842015-09-15 12:18:29 +00006133 case PREDEF_TYPE_AUTO_DEDUCT:
6134 T = Context.getAutoDeductType();
6135 break;
6136
6137 case PREDEF_TYPE_AUTO_RREF_DEDUCT:
6138 T = Context.getAutoRRefDeductType();
Guy Benyei11169dd2012-12-18 14:30:41 +00006139 break;
6140
6141 case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
6142 T = Context.ARCUnbridgedCastTy;
6143 break;
6144
Guy Benyei11169dd2012-12-18 14:30:41 +00006145 case PREDEF_TYPE_BUILTIN_FN:
6146 T = Context.BuiltinFnTy;
6147 break;
Alexey Bataev1a3320e2015-08-25 14:24:04 +00006148
6149 case PREDEF_TYPE_OMP_ARRAY_SECTION:
6150 T = Context.OMPArraySectionTy;
6151 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00006152 }
6153
6154 assert(!T.isNull() && "Unknown predefined type");
6155 return T.withFastQualifiers(FastQuals);
6156 }
6157
6158 Index -= NUM_PREDEF_TYPE_IDS;
6159 assert(Index < TypesLoaded.size() && "Type index out-of-range");
6160 if (TypesLoaded[Index].isNull()) {
6161 TypesLoaded[Index] = readTypeRecord(Index);
6162 if (TypesLoaded[Index].isNull())
6163 return QualType();
6164
6165 TypesLoaded[Index]->setFromAST();
6166 if (DeserializationListener)
6167 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
6168 TypesLoaded[Index]);
6169 }
6170
6171 return TypesLoaded[Index].withFastQualifiers(FastQuals);
6172}
6173
6174QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
6175 return GetType(getGlobalTypeID(F, LocalID));
6176}
6177
6178serialization::TypeID
6179ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
6180 unsigned FastQuals = LocalID & Qualifiers::FastMask;
6181 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
6182
6183 if (LocalIndex < NUM_PREDEF_TYPE_IDS)
6184 return LocalID;
6185
6186 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6187 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
6188 assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
6189
6190 unsigned GlobalIndex = LocalIndex + I->second;
6191 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
6192}
6193
6194TemplateArgumentLocInfo
6195ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
6196 TemplateArgument::ArgKind Kind,
6197 const RecordData &Record,
6198 unsigned &Index) {
6199 switch (Kind) {
6200 case TemplateArgument::Expression:
6201 return ReadExpr(F);
6202 case TemplateArgument::Type:
6203 return GetTypeSourceInfo(F, Record, Index);
6204 case TemplateArgument::Template: {
6205 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6206 Index);
6207 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6208 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6209 SourceLocation());
6210 }
6211 case TemplateArgument::TemplateExpansion: {
6212 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
6213 Index);
6214 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
6215 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
6216 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
6217 EllipsisLoc);
6218 }
6219 case TemplateArgument::Null:
6220 case TemplateArgument::Integral:
6221 case TemplateArgument::Declaration:
6222 case TemplateArgument::NullPtr:
6223 case TemplateArgument::Pack:
6224 // FIXME: Is this right?
6225 return TemplateArgumentLocInfo();
6226 }
6227 llvm_unreachable("unexpected template argument loc");
6228}
6229
6230TemplateArgumentLoc
6231ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
6232 const RecordData &Record, unsigned &Index) {
6233 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
6234
6235 if (Arg.getKind() == TemplateArgument::Expression) {
6236 if (Record[Index++]) // bool InfoHasSameExpr.
6237 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
6238 }
6239 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
6240 Record, Index));
6241}
6242
Enea Zaffanella6dbe1872013-08-10 07:24:53 +00006243const ASTTemplateArgumentListInfo*
6244ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
6245 const RecordData &Record,
6246 unsigned &Index) {
6247 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
6248 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
6249 unsigned NumArgsAsWritten = Record[Index++];
6250 TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
6251 for (unsigned i = 0; i != NumArgsAsWritten; ++i)
6252 TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
6253 return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
6254}
6255
Guy Benyei11169dd2012-12-18 14:30:41 +00006256Decl *ASTReader::GetExternalDecl(uint32_t ID) {
6257 return GetDecl(ID);
6258}
6259
Richard Smith50895422015-01-31 03:04:55 +00006260template<typename TemplateSpecializationDecl>
6261static void completeRedeclChainForTemplateSpecialization(Decl *D) {
6262 if (auto *TSD = dyn_cast<TemplateSpecializationDecl>(D))
6263 TSD->getSpecializedTemplate()->LoadLazySpecializations();
6264}
6265
Richard Smith053f6c62014-05-16 23:01:30 +00006266void ASTReader::CompleteRedeclChain(const Decl *D) {
Richard Smith851072e2014-05-19 20:59:20 +00006267 if (NumCurrentElementsDeserializing) {
6268 // We arrange to not care about the complete redeclaration chain while we're
6269 // deserializing. Just remember that the AST has marked this one as complete
6270 // but that it's not actually complete yet, so we know we still need to
6271 // complete it later.
6272 PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
6273 return;
6274 }
6275
Richard Smith053f6c62014-05-16 23:01:30 +00006276 const DeclContext *DC = D->getDeclContext()->getRedeclContext();
6277
Richard Smith053f6c62014-05-16 23:01:30 +00006278 // If this is a named declaration, complete it by looking it up
6279 // within its context.
6280 //
Richard Smith01bdb7a2014-08-28 05:44:07 +00006281 // FIXME: Merging a function definition should merge
Richard Smith053f6c62014-05-16 23:01:30 +00006282 // all mergeable entities within it.
6283 if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
6284 isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
6285 if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
Richard Smitha534a312015-07-21 23:54:07 +00006286 if (!getContext().getLangOpts().CPlusPlus &&
6287 isa<TranslationUnitDecl>(DC)) {
Richard Smith053f6c62014-05-16 23:01:30 +00006288 // Outside of C++, we don't have a lookup table for the TU, so update
Richard Smitha534a312015-07-21 23:54:07 +00006289 // the identifier instead. (For C++ modules, we don't store decls
6290 // in the serialized identifier table, so we do the lookup in the TU.)
6291 auto *II = Name.getAsIdentifierInfo();
6292 assert(II && "non-identifier name in C?");
Richard Smith053f6c62014-05-16 23:01:30 +00006293 if (II->isOutOfDate())
6294 updateOutOfDateIdentifier(*II);
6295 } else
6296 DC->lookup(Name);
Richard Smith01bdb7a2014-08-28 05:44:07 +00006297 } else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
Richard Smith3cb15722015-08-05 22:41:45 +00006298 // Find all declarations of this kind from the relevant context.
6299 for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
6300 auto *DC = cast<DeclContext>(DCDecl);
6301 SmallVector<Decl*, 8> Decls;
6302 FindExternalLexicalDecls(
6303 DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
6304 }
Richard Smith053f6c62014-05-16 23:01:30 +00006305 }
6306 }
Richard Smith50895422015-01-31 03:04:55 +00006307
6308 if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
6309 CTSD->getSpecializedTemplate()->LoadLazySpecializations();
6310 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
6311 VTSD->getSpecializedTemplate()->LoadLazySpecializations();
6312 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
6313 if (auto *Template = FD->getPrimaryTemplate())
6314 Template->LoadLazySpecializations();
6315 }
Richard Smith053f6c62014-05-16 23:01:30 +00006316}
6317
Richard Smithc2bb8182015-03-24 06:36:48 +00006318uint64_t ASTReader::ReadCXXCtorInitializersRef(ModuleFile &M,
6319 const RecordData &Record,
6320 unsigned &Idx) {
6321 if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXCtorInitializers) {
6322 Error("malformed AST file: missing C++ ctor initializers");
6323 return 0;
6324 }
6325
6326 unsigned LocalID = Record[Idx++];
6327 return getGlobalBitOffset(M, M.CXXCtorInitializersOffsets[LocalID - 1]);
6328}
6329
6330CXXCtorInitializer **
6331ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
6332 RecordLocation Loc = getLocalBitOffset(Offset);
6333 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
6334 SavedStreamPosition SavedPosition(Cursor);
6335 Cursor.JumpToBit(Loc.Offset);
6336 ReadingKindTracker ReadingKind(Read_Decl, *this);
6337
6338 RecordData Record;
6339 unsigned Code = Cursor.ReadCode();
6340 unsigned RecCode = Cursor.readRecord(Code, Record);
6341 if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
6342 Error("malformed AST file: missing C++ ctor initializers");
6343 return nullptr;
6344 }
6345
6346 unsigned Idx = 0;
6347 return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
6348}
6349
Richard Smithcd45dbc2014-04-19 03:48:30 +00006350uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M,
6351 const RecordData &Record,
6352 unsigned &Idx) {
6353 if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXBaseSpecifiers) {
6354 Error("malformed AST file: missing C++ base specifier");
Guy Benyei11169dd2012-12-18 14:30:41 +00006355 return 0;
Richard Smithcd45dbc2014-04-19 03:48:30 +00006356 }
6357
Guy Benyei11169dd2012-12-18 14:30:41 +00006358 unsigned LocalID = Record[Idx++];
6359 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
6360}
6361
6362CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
6363 RecordLocation Loc = getLocalBitOffset(Offset);
Chris Lattner7fb3bef2013-01-20 00:56:42 +00006364 BitstreamCursor &Cursor = Loc.F->DeclsCursor;
Guy Benyei11169dd2012-12-18 14:30:41 +00006365 SavedStreamPosition SavedPosition(Cursor);
6366 Cursor.JumpToBit(Loc.Offset);
6367 ReadingKindTracker ReadingKind(Read_Decl, *this);
6368 RecordData Record;
6369 unsigned Code = Cursor.ReadCode();
Chris Lattner0e6c9402013-01-20 02:38:54 +00006370 unsigned RecCode = Cursor.readRecord(Code, Record);
Guy Benyei11169dd2012-12-18 14:30:41 +00006371 if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
Richard Smithcd45dbc2014-04-19 03:48:30 +00006372 Error("malformed AST file: missing C++ base specifiers");
Craig Toppera13603a2014-05-22 05:54:18 +00006373 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00006374 }
6375
6376 unsigned Idx = 0;
6377 unsigned NumBases = Record[Idx++];
6378 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
6379 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
6380 for (unsigned I = 0; I != NumBases; ++I)
6381 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
6382 return Bases;
6383}
6384
6385serialization::DeclID
6386ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
6387 if (LocalID < NUM_PREDEF_DECL_IDS)
6388 return LocalID;
6389
6390 ContinuousRangeMap<uint32_t, int, 2>::iterator I
6391 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
6392 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
6393
6394 return LocalID + I->second;
6395}
6396
6397bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
6398 ModuleFile &M) const {
Richard Smithfe620d22015-03-05 23:24:12 +00006399 // Predefined decls aren't from any module.
6400 if (ID < NUM_PREDEF_DECL_IDS)
6401 return false;
6402
Richard Smithbcda1a92015-07-12 23:51:20 +00006403 return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
6404 ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
Guy Benyei11169dd2012-12-18 14:30:41 +00006405}
6406
Douglas Gregor9f782892013-01-21 15:25:38 +00006407ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
Guy Benyei11169dd2012-12-18 14:30:41 +00006408 if (!D->isFromASTFile())
Craig Toppera13603a2014-05-22 05:54:18 +00006409 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00006410 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
6411 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6412 return I->second;
6413}
6414
6415SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
6416 if (ID < NUM_PREDEF_DECL_IDS)
6417 return SourceLocation();
Richard Smithcd45dbc2014-04-19 03:48:30 +00006418
Guy Benyei11169dd2012-12-18 14:30:41 +00006419 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6420
6421 if (Index > DeclsLoaded.size()) {
6422 Error("declaration ID out-of-range for AST file");
6423 return SourceLocation();
6424 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00006425
Guy Benyei11169dd2012-12-18 14:30:41 +00006426 if (Decl *D = DeclsLoaded[Index])
6427 return D->getLocation();
6428
Richard Smithcb34bd32016-03-27 07:28:06 +00006429 SourceLocation Loc;
6430 DeclCursorForID(ID, Loc);
6431 return Loc;
Guy Benyei11169dd2012-12-18 14:30:41 +00006432}
6433
Richard Smithfe620d22015-03-05 23:24:12 +00006434static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
6435 switch (ID) {
6436 case PREDEF_DECL_NULL_ID:
6437 return nullptr;
6438
6439 case PREDEF_DECL_TRANSLATION_UNIT_ID:
6440 return Context.getTranslationUnitDecl();
6441
6442 case PREDEF_DECL_OBJC_ID_ID:
6443 return Context.getObjCIdDecl();
6444
6445 case PREDEF_DECL_OBJC_SEL_ID:
6446 return Context.getObjCSelDecl();
6447
6448 case PREDEF_DECL_OBJC_CLASS_ID:
6449 return Context.getObjCClassDecl();
6450
6451 case PREDEF_DECL_OBJC_PROTOCOL_ID:
6452 return Context.getObjCProtocolDecl();
6453
6454 case PREDEF_DECL_INT_128_ID:
6455 return Context.getInt128Decl();
6456
6457 case PREDEF_DECL_UNSIGNED_INT_128_ID:
6458 return Context.getUInt128Decl();
6459
6460 case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
6461 return Context.getObjCInstanceTypeDecl();
6462
6463 case PREDEF_DECL_BUILTIN_VA_LIST_ID:
6464 return Context.getBuiltinVaListDecl();
Richard Smithf19e1272015-03-07 00:04:49 +00006465
Richard Smith9b88a4c2015-07-27 05:40:23 +00006466 case PREDEF_DECL_VA_LIST_TAG:
6467 return Context.getVaListTagDecl();
6468
Charles Davisc7d5c942015-09-17 20:55:33 +00006469 case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
6470 return Context.getBuiltinMSVaListDecl();
6471
Richard Smithf19e1272015-03-07 00:04:49 +00006472 case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
6473 return Context.getExternCContextDecl();
David Majnemerd9b1a4f2015-11-04 03:40:30 +00006474
6475 case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
6476 return Context.getMakeIntegerSeqDecl();
Quentin Colombet043406b2016-02-03 22:41:00 +00006477
6478 case PREDEF_DECL_CF_CONSTANT_STRING_ID:
6479 return Context.getCFConstantStringDecl();
Ben Langmuirf5416742016-02-04 00:55:24 +00006480
6481 case PREDEF_DECL_CF_CONSTANT_STRING_TAG_ID:
6482 return Context.getCFConstantStringTagDecl();
Richard Smithfe620d22015-03-05 23:24:12 +00006483 }
Yaron Keren322bdad2015-03-06 07:49:14 +00006484 llvm_unreachable("PredefinedDeclIDs unknown enum value");
Richard Smithfe620d22015-03-05 23:24:12 +00006485}
6486
Richard Smithcd45dbc2014-04-19 03:48:30 +00006487Decl *ASTReader::GetExistingDecl(DeclID ID) {
6488 if (ID < NUM_PREDEF_DECL_IDS) {
Richard Smithfe620d22015-03-05 23:24:12 +00006489 Decl *D = getPredefinedDecl(Context, (PredefinedDeclIDs)ID);
6490 if (D) {
6491 // Track that we have merged the declaration with ID \p ID into the
6492 // pre-existing predefined declaration \p D.
Richard Smith5fc18a92015-07-12 23:43:21 +00006493 auto &Merged = KeyDecls[D->getCanonicalDecl()];
Richard Smithfe620d22015-03-05 23:24:12 +00006494 if (Merged.empty())
6495 Merged.push_back(ID);
Guy Benyei11169dd2012-12-18 14:30:41 +00006496 }
Richard Smithfe620d22015-03-05 23:24:12 +00006497 return D;
Guy Benyei11169dd2012-12-18 14:30:41 +00006498 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00006499
Guy Benyei11169dd2012-12-18 14:30:41 +00006500 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6501
6502 if (Index >= DeclsLoaded.size()) {
6503 assert(0 && "declaration ID out-of-range for AST file");
6504 Error("declaration ID out-of-range for AST file");
Craig Toppera13603a2014-05-22 05:54:18 +00006505 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00006506 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00006507
6508 return DeclsLoaded[Index];
6509}
6510
6511Decl *ASTReader::GetDecl(DeclID ID) {
6512 if (ID < NUM_PREDEF_DECL_IDS)
6513 return GetExistingDecl(ID);
6514
6515 unsigned Index = ID - NUM_PREDEF_DECL_IDS;
6516
6517 if (Index >= DeclsLoaded.size()) {
6518 assert(0 && "declaration ID out-of-range for AST file");
6519 Error("declaration ID out-of-range for AST file");
Craig Toppera13603a2014-05-22 05:54:18 +00006520 return nullptr;
Richard Smithcd45dbc2014-04-19 03:48:30 +00006521 }
6522
Guy Benyei11169dd2012-12-18 14:30:41 +00006523 if (!DeclsLoaded[Index]) {
6524 ReadDeclRecord(ID);
6525 if (DeserializationListener)
6526 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
6527 }
6528
6529 return DeclsLoaded[Index];
6530}
6531
6532DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
6533 DeclID GlobalID) {
6534 if (GlobalID < NUM_PREDEF_DECL_IDS)
6535 return GlobalID;
6536
6537 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
6538 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
6539 ModuleFile *Owner = I->second;
6540
6541 llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
6542 = M.GlobalToLocalDeclIDs.find(Owner);
6543 if (Pos == M.GlobalToLocalDeclIDs.end())
6544 return 0;
6545
6546 return GlobalID - Owner->BaseDeclID + Pos->second;
6547}
6548
6549serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
6550 const RecordData &Record,
6551 unsigned &Idx) {
6552 if (Idx >= Record.size()) {
6553 Error("Corrupted AST file");
6554 return 0;
6555 }
6556
6557 return getGlobalDeclID(F, Record[Idx++]);
6558}
6559
6560/// \brief Resolve the offset of a statement into a statement.
6561///
6562/// This operation will read a new statement from the external
6563/// source each time it is called, and is meant to be used via a
6564/// LazyOffsetPtr (which is used by Decls for the body of functions, etc).
6565Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
6566 // Switch case IDs are per Decl.
6567 ClearSwitchCaseIDs();
6568
6569 // Offset here is a global offset across the entire chain.
6570 RecordLocation Loc = getLocalBitOffset(Offset);
6571 Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
6572 return ReadStmtFromStream(*Loc.F);
6573}
6574
Richard Smith3cb15722015-08-05 22:41:45 +00006575void ASTReader::FindExternalLexicalDecls(
6576 const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
6577 SmallVectorImpl<Decl *> &Decls) {
Richard Smith82f8fcd2015-08-06 22:07:25 +00006578 bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
6579
Richard Smith9ccdd932015-08-06 22:14:12 +00006580 auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
Richard Smith82f8fcd2015-08-06 22:07:25 +00006581 assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
6582 for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
6583 auto K = (Decl::Kind)+LexicalDecls[I];
6584 if (!IsKindWeWant(K))
6585 continue;
6586
6587 auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
6588
6589 // Don't add predefined declarations to the lexical context more
6590 // than once.
6591 if (ID < NUM_PREDEF_DECL_IDS) {
6592 if (PredefsVisited[ID])
6593 continue;
6594
6595 PredefsVisited[ID] = true;
6596 }
6597
6598 if (Decl *D = GetLocalDecl(*M, ID)) {
Richard Smith2317a3e2015-08-11 21:21:20 +00006599 assert(D->getKind() == K && "wrong kind for lexical decl");
Richard Smith82f8fcd2015-08-06 22:07:25 +00006600 if (!DC->isDeclInLexicalTraversal(D))
6601 Decls.push_back(D);
6602 }
6603 }
6604 };
6605
6606 if (isa<TranslationUnitDecl>(DC)) {
6607 for (auto Lexical : TULexicalDecls)
6608 Visit(Lexical.first, Lexical.second);
6609 } else {
6610 auto I = LexicalDecls.find(DC);
6611 if (I != LexicalDecls.end())
Richard Smith9c9173d2015-08-11 22:00:24 +00006612 Visit(I->second.first, I->second.second);
Richard Smith82f8fcd2015-08-06 22:07:25 +00006613 }
6614
Guy Benyei11169dd2012-12-18 14:30:41 +00006615 ++NumLexicalDeclContextsRead;
Guy Benyei11169dd2012-12-18 14:30:41 +00006616}
6617
6618namespace {
6619
6620class DeclIDComp {
6621 ASTReader &Reader;
6622 ModuleFile &Mod;
6623
6624public:
6625 DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
6626
6627 bool operator()(LocalDeclID L, LocalDeclID R) const {
6628 SourceLocation LHS = getLocation(L);
6629 SourceLocation RHS = getLocation(R);
6630 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6631 }
6632
6633 bool operator()(SourceLocation LHS, LocalDeclID R) const {
6634 SourceLocation RHS = getLocation(R);
6635 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6636 }
6637
6638 bool operator()(LocalDeclID L, SourceLocation RHS) const {
6639 SourceLocation LHS = getLocation(L);
6640 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
6641 }
6642
6643 SourceLocation getLocation(LocalDeclID ID) const {
6644 return Reader.getSourceManager().getFileLoc(
6645 Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
6646 }
6647};
6648
Alexander Kornienkoab9db512015-06-22 23:07:51 +00006649}
Guy Benyei11169dd2012-12-18 14:30:41 +00006650
6651void ASTReader::FindFileRegionDecls(FileID File,
6652 unsigned Offset, unsigned Length,
6653 SmallVectorImpl<Decl *> &Decls) {
6654 SourceManager &SM = getSourceManager();
6655
6656 llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
6657 if (I == FileDeclIDs.end())
6658 return;
6659
6660 FileDeclsInfo &DInfo = I->second;
6661 if (DInfo.Decls.empty())
6662 return;
6663
6664 SourceLocation
6665 BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
6666 SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
6667
6668 DeclIDComp DIDComp(*this, *DInfo.Mod);
6669 ArrayRef<serialization::LocalDeclID>::iterator
6670 BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6671 BeginLoc, DIDComp);
6672 if (BeginIt != DInfo.Decls.begin())
6673 --BeginIt;
6674
6675 // If we are pointing at a top-level decl inside an objc container, we need
6676 // to backtrack until we find it otherwise we will fail to report that the
6677 // region overlaps with an objc container.
6678 while (BeginIt != DInfo.Decls.begin() &&
6679 GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
6680 ->isTopLevelDeclInObjCContainer())
6681 --BeginIt;
6682
6683 ArrayRef<serialization::LocalDeclID>::iterator
6684 EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
6685 EndLoc, DIDComp);
6686 if (EndIt != DInfo.Decls.end())
6687 ++EndIt;
6688
6689 for (ArrayRef<serialization::LocalDeclID>::iterator
6690 DIt = BeginIt; DIt != EndIt; ++DIt)
6691 Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
6692}
6693
Richard Smith9ce12e32013-02-07 03:30:24 +00006694bool
Guy Benyei11169dd2012-12-18 14:30:41 +00006695ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
6696 DeclarationName Name) {
Richard Smithd88a7f12015-09-01 20:35:42 +00006697 assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
Guy Benyei11169dd2012-12-18 14:30:41 +00006698 "DeclContext has no visible decls in storage");
6699 if (!Name)
Richard Smith9ce12e32013-02-07 03:30:24 +00006700 return false;
Guy Benyei11169dd2012-12-18 14:30:41 +00006701
Richard Smithd88a7f12015-09-01 20:35:42 +00006702 auto It = Lookups.find(DC);
6703 if (It == Lookups.end())
6704 return false;
6705
Richard Smith8c913ec2014-08-14 02:21:01 +00006706 Deserializing LookupResults(this);
6707
Richard Smithd88a7f12015-09-01 20:35:42 +00006708 // Load the list of declarations.
Guy Benyei11169dd2012-12-18 14:30:41 +00006709 SmallVector<NamedDecl *, 64> Decls;
Richard Smithd88a7f12015-09-01 20:35:42 +00006710 for (DeclID ID : It->second.Table.find(Name)) {
6711 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6712 if (ND->getDeclName() == Name)
6713 Decls.push_back(ND);
6714 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00006715
Guy Benyei11169dd2012-12-18 14:30:41 +00006716 ++NumVisibleDeclContextsRead;
6717 SetExternalVisibleDeclsForName(DC, Name, Decls);
Richard Smith9ce12e32013-02-07 03:30:24 +00006718 return !Decls.empty();
Guy Benyei11169dd2012-12-18 14:30:41 +00006719}
6720
Guy Benyei11169dd2012-12-18 14:30:41 +00006721void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
6722 if (!DC->hasExternalVisibleStorage())
6723 return;
Richard Smithd88a7f12015-09-01 20:35:42 +00006724
6725 auto It = Lookups.find(DC);
6726 assert(It != Lookups.end() &&
6727 "have external visible storage but no lookup tables");
6728
Craig Topper79be4cd2013-07-05 04:33:53 +00006729 DeclsMap Decls;
Guy Benyei11169dd2012-12-18 14:30:41 +00006730
Richard Smithd88a7f12015-09-01 20:35:42 +00006731 for (DeclID ID : It->second.Table.findAll()) {
6732 NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
6733 Decls[ND->getDeclName()].push_back(ND);
Guy Benyei11169dd2012-12-18 14:30:41 +00006734 }
6735
Guy Benyei11169dd2012-12-18 14:30:41 +00006736 ++NumVisibleDeclContextsRead;
6737
Craig Topper79be4cd2013-07-05 04:33:53 +00006738 for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
Guy Benyei11169dd2012-12-18 14:30:41 +00006739 SetExternalVisibleDeclsForName(DC, I->first, I->second);
6740 }
6741 const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
6742}
6743
Richard Smithd88a7f12015-09-01 20:35:42 +00006744const serialization::reader::DeclContextLookupTable *
6745ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
6746 auto I = Lookups.find(Primary);
6747 return I == Lookups.end() ? nullptr : &I->second;
6748}
6749
Guy Benyei11169dd2012-12-18 14:30:41 +00006750/// \brief Under non-PCH compilation the consumer receives the objc methods
6751/// before receiving the implementation, and codegen depends on this.
6752/// We simulate this by deserializing and passing to consumer the methods of the
6753/// implementation before passing the deserialized implementation decl.
6754static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
6755 ASTConsumer *Consumer) {
6756 assert(ImplD && Consumer);
6757
Aaron Ballmanaff18c02014-03-13 19:03:34 +00006758 for (auto *I : ImplD->methods())
6759 Consumer->HandleInterestingDecl(DeclGroupRef(I));
Guy Benyei11169dd2012-12-18 14:30:41 +00006760
6761 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
6762}
6763
6764void ASTReader::PassInterestingDeclsToConsumer() {
6765 assert(Consumer);
Richard Smith04d05b52014-03-23 00:27:18 +00006766
6767 if (PassingDeclsToConsumer)
6768 return;
6769
6770 // Guard variable to avoid recursively redoing the process of passing
6771 // decls to consumer.
6772 SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
6773 true);
6774
Richard Smith9e2341d2015-03-23 03:25:59 +00006775 // Ensure that we've loaded all potentially-interesting declarations
6776 // that need to be eagerly loaded.
6777 for (auto ID : EagerlyDeserializedDecls)
6778 GetDecl(ID);
6779 EagerlyDeserializedDecls.clear();
6780
Guy Benyei11169dd2012-12-18 14:30:41 +00006781 while (!InterestingDecls.empty()) {
6782 Decl *D = InterestingDecls.front();
6783 InterestingDecls.pop_front();
6784
6785 PassInterestingDeclToConsumer(D);
6786 }
6787}
6788
6789void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
6790 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
6791 PassObjCImplDeclToConsumer(ImplD, Consumer);
6792 else
6793 Consumer->HandleInterestingDecl(DeclGroupRef(D));
6794}
6795
6796void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
6797 this->Consumer = Consumer;
6798
Richard Smith9e2341d2015-03-23 03:25:59 +00006799 if (Consumer)
6800 PassInterestingDeclsToConsumer();
Richard Smith7f330cd2015-03-18 01:42:29 +00006801
6802 if (DeserializationListener)
6803 DeserializationListener->ReaderInitialized(this);
Guy Benyei11169dd2012-12-18 14:30:41 +00006804}
6805
6806void ASTReader::PrintStats() {
6807 std::fprintf(stderr, "*** AST File Statistics:\n");
6808
6809 unsigned NumTypesLoaded
6810 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
6811 QualType());
6812 unsigned NumDeclsLoaded
6813 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
Craig Toppera13603a2014-05-22 05:54:18 +00006814 (Decl *)nullptr);
Guy Benyei11169dd2012-12-18 14:30:41 +00006815 unsigned NumIdentifiersLoaded
6816 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
6817 IdentifiersLoaded.end(),
Craig Toppera13603a2014-05-22 05:54:18 +00006818 (IdentifierInfo *)nullptr);
Guy Benyei11169dd2012-12-18 14:30:41 +00006819 unsigned NumMacrosLoaded
6820 = MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
6821 MacrosLoaded.end(),
Craig Toppera13603a2014-05-22 05:54:18 +00006822 (MacroInfo *)nullptr);
Guy Benyei11169dd2012-12-18 14:30:41 +00006823 unsigned NumSelectorsLoaded
6824 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
6825 SelectorsLoaded.end(),
6826 Selector());
6827
6828 if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
6829 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
6830 NumSLocEntriesRead, TotalNumSLocEntries,
6831 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
6832 if (!TypesLoaded.empty())
6833 std::fprintf(stderr, " %u/%u types read (%f%%)\n",
6834 NumTypesLoaded, (unsigned)TypesLoaded.size(),
6835 ((float)NumTypesLoaded/TypesLoaded.size() * 100));
6836 if (!DeclsLoaded.empty())
6837 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
6838 NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
6839 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
6840 if (!IdentifiersLoaded.empty())
6841 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
6842 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
6843 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
6844 if (!MacrosLoaded.empty())
6845 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6846 NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
6847 ((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
6848 if (!SelectorsLoaded.empty())
6849 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
6850 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
6851 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
6852 if (TotalNumStatements)
6853 std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
6854 NumStatementsRead, TotalNumStatements,
6855 ((float)NumStatementsRead/TotalNumStatements * 100));
6856 if (TotalNumMacros)
6857 std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
6858 NumMacrosRead, TotalNumMacros,
6859 ((float)NumMacrosRead/TotalNumMacros * 100));
6860 if (TotalLexicalDeclContexts)
6861 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
6862 NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
6863 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
6864 * 100));
6865 if (TotalVisibleDeclContexts)
6866 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
6867 NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
6868 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
6869 * 100));
6870 if (TotalNumMethodPoolEntries) {
6871 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
6872 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
6873 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
6874 * 100));
Guy Benyei11169dd2012-12-18 14:30:41 +00006875 }
Douglas Gregorad2f7a52013-01-28 17:54:36 +00006876 if (NumMethodPoolLookups) {
6877 std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
6878 NumMethodPoolHits, NumMethodPoolLookups,
6879 ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
6880 }
6881 if (NumMethodPoolTableLookups) {
6882 std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
6883 NumMethodPoolTableHits, NumMethodPoolTableLookups,
6884 ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
6885 * 100.0));
6886 }
6887
Douglas Gregor00a50f72013-01-25 00:38:33 +00006888 if (NumIdentifierLookupHits) {
6889 std::fprintf(stderr,
6890 " %u / %u identifier table lookups succeeded (%f%%)\n",
6891 NumIdentifierLookupHits, NumIdentifierLookups,
6892 (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
6893 }
6894
Douglas Gregore060e572013-01-25 01:03:03 +00006895 if (GlobalIndex) {
6896 std::fprintf(stderr, "\n");
6897 GlobalIndex->printStats();
6898 }
6899
Guy Benyei11169dd2012-12-18 14:30:41 +00006900 std::fprintf(stderr, "\n");
6901 dump();
6902 std::fprintf(stderr, "\n");
6903}
6904
6905template<typename Key, typename ModuleFile, unsigned InitialCapacity>
6906static void
6907dumpModuleIDMap(StringRef Name,
6908 const ContinuousRangeMap<Key, ModuleFile *,
6909 InitialCapacity> &Map) {
6910 if (Map.begin() == Map.end())
6911 return;
6912
6913 typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
6914 llvm::errs() << Name << ":\n";
6915 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
6916 I != IEnd; ++I) {
6917 llvm::errs() << " " << I->first << " -> " << I->second->FileName
6918 << "\n";
6919 }
6920}
6921
Yaron Kerencdae9412016-01-29 19:38:18 +00006922LLVM_DUMP_METHOD void ASTReader::dump() {
Guy Benyei11169dd2012-12-18 14:30:41 +00006923 llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
6924 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
6925 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
6926 dumpModuleIDMap("Global type map", GlobalTypeMap);
6927 dumpModuleIDMap("Global declaration map", GlobalDeclMap);
6928 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
6929 dumpModuleIDMap("Global macro map", GlobalMacroMap);
6930 dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
6931 dumpModuleIDMap("Global selector map", GlobalSelectorMap);
6932 dumpModuleIDMap("Global preprocessed entity map",
6933 GlobalPreprocessedEntityMap);
6934
6935 llvm::errs() << "\n*** PCH/Modules Loaded:";
6936 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
6937 MEnd = ModuleMgr.end();
6938 M != MEnd; ++M)
6939 (*M)->dump();
6940}
6941
6942/// Return the amount of memory used by memory buffers, breaking down
6943/// by heap-backed versus mmap'ed memory.
6944void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
6945 for (ModuleConstIterator I = ModuleMgr.begin(),
6946 E = ModuleMgr.end(); I != E; ++I) {
6947 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
6948 size_t bytes = buf->getBufferSize();
6949 switch (buf->getBufferKind()) {
6950 case llvm::MemoryBuffer::MemoryBuffer_Malloc:
6951 sizes.malloc_bytes += bytes;
6952 break;
6953 case llvm::MemoryBuffer::MemoryBuffer_MMap:
6954 sizes.mmap_bytes += bytes;
6955 break;
6956 }
6957 }
6958 }
6959}
6960
6961void ASTReader::InitializeSema(Sema &S) {
6962 SemaObj = &S;
6963 S.addExternalSource(this);
6964
6965 // Makes sure any declarations that were deserialized "too early"
6966 // still get added to the identifier's declaration chains.
Ben Langmuir5418f402014-09-10 21:29:41 +00006967 for (uint64_t ID : PreloadedDeclIDs) {
6968 NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
6969 pushExternalDeclIntoScope(D, D->getDeclName());
Guy Benyei11169dd2012-12-18 14:30:41 +00006970 }
Ben Langmuir5418f402014-09-10 21:29:41 +00006971 PreloadedDeclIDs.clear();
Guy Benyei11169dd2012-12-18 14:30:41 +00006972
Richard Smith3d8e97e2013-10-18 06:54:39 +00006973 // FIXME: What happens if these are changed by a module import?
Guy Benyei11169dd2012-12-18 14:30:41 +00006974 if (!FPPragmaOptions.empty()) {
6975 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
6976 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
6977 }
6978
Richard Smith3d8e97e2013-10-18 06:54:39 +00006979 // FIXME: What happens if these are changed by a module import?
Guy Benyei11169dd2012-12-18 14:30:41 +00006980 if (!OpenCLExtensions.empty()) {
6981 unsigned I = 0;
6982#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
6983#include "clang/Basic/OpenCLExtensions.def"
6984
6985 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
6986 }
Richard Smith3d8e97e2013-10-18 06:54:39 +00006987
6988 UpdateSema();
6989}
6990
6991void ASTReader::UpdateSema() {
6992 assert(SemaObj && "no Sema to update");
6993
6994 // Load the offsets of the declarations that Sema references.
6995 // They will be lazily deserialized when needed.
6996 if (!SemaDeclRefs.empty()) {
6997 assert(SemaDeclRefs.size() % 2 == 0);
6998 for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) {
6999 if (!SemaObj->StdNamespace)
7000 SemaObj->StdNamespace = SemaDeclRefs[I];
7001 if (!SemaObj->StdBadAlloc)
7002 SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
7003 }
7004 SemaDeclRefs.clear();
7005 }
Dario Domizioli13a0a382014-05-23 12:13:25 +00007006
Nico Weber779355f2016-03-02 23:22:00 +00007007 // Update the state of pragmas. Use the same API as if we had encountered the
7008 // pragma in the source.
Dario Domizioli13a0a382014-05-23 12:13:25 +00007009 if(OptimizeOffPragmaLocation.isValid())
7010 SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
Nico Weber779355f2016-03-02 23:22:00 +00007011 if (PragmaMSStructState != -1)
7012 SemaObj->ActOnPragmaMSStruct((PragmaMSStructKind)PragmaMSStructState);
Nico Weber42932312016-03-03 00:17:35 +00007013 if (PointersToMembersPragmaLocation.isValid()) {
7014 SemaObj->ActOnPragmaMSPointersToMembers(
7015 (LangOptions::PragmaMSPointersToMembersKind)
7016 PragmaMSPointersToMembersState,
7017 PointersToMembersPragmaLocation);
7018 }
Guy Benyei11169dd2012-12-18 14:30:41 +00007019}
7020
Richard Smitha8d5b6a2015-07-17 19:51:03 +00007021IdentifierInfo *ASTReader::get(StringRef Name) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007022 // Note that we are loading an identifier.
7023 Deserializing AnIdentifier(this);
Douglas Gregore060e572013-01-25 01:03:03 +00007024
Douglas Gregor7211ac12013-01-25 23:32:03 +00007025 IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
Douglas Gregor00a50f72013-01-25 00:38:33 +00007026 NumIdentifierLookups,
7027 NumIdentifierLookupHits);
Richard Smith33e0f7e2015-07-22 02:08:40 +00007028
7029 // We don't need to do identifier table lookups in C++ modules (we preload
7030 // all interesting declarations, and don't need to use the scope for name
7031 // lookups). Perform the lookup in PCH files, though, since we don't build
7032 // a complete initial identifier table if we're carrying on from a PCH.
7033 if (Context.getLangOpts().CPlusPlus) {
7034 for (auto F : ModuleMgr.pch_modules())
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00007035 if (Visitor(*F))
Richard Smith33e0f7e2015-07-22 02:08:40 +00007036 break;
7037 } else {
7038 // If there is a global index, look there first to determine which modules
7039 // provably do not have any results for this identifier.
7040 GlobalModuleIndex::HitSet Hits;
7041 GlobalModuleIndex::HitSet *HitsPtr = nullptr;
7042 if (!loadGlobalIndex()) {
7043 if (GlobalIndex->lookupIdentifier(Name, Hits)) {
7044 HitsPtr = &Hits;
7045 }
7046 }
7047
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00007048 ModuleMgr.visit(Visitor, HitsPtr);
Richard Smith33e0f7e2015-07-22 02:08:40 +00007049 }
7050
Guy Benyei11169dd2012-12-18 14:30:41 +00007051 IdentifierInfo *II = Visitor.getIdentifierInfo();
7052 markIdentifierUpToDate(II);
7053 return II;
7054}
7055
7056namespace clang {
7057 /// \brief An identifier-lookup iterator that enumerates all of the
7058 /// identifiers stored within a set of AST files.
7059 class ASTIdentifierIterator : public IdentifierIterator {
7060 /// \brief The AST reader whose identifiers are being enumerated.
7061 const ASTReader &Reader;
7062
7063 /// \brief The current index into the chain of AST files stored in
7064 /// the AST reader.
7065 unsigned Index;
7066
7067 /// \brief The current position within the identifier lookup table
7068 /// of the current AST file.
7069 ASTIdentifierLookupTable::key_iterator Current;
7070
7071 /// \brief The end position within the identifier lookup table of
7072 /// the current AST file.
7073 ASTIdentifierLookupTable::key_iterator End;
7074
7075 public:
7076 explicit ASTIdentifierIterator(const ASTReader &Reader);
7077
Craig Topper3e89dfe2014-03-13 02:13:41 +00007078 StringRef Next() override;
Guy Benyei11169dd2012-12-18 14:30:41 +00007079 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00007080}
Guy Benyei11169dd2012-12-18 14:30:41 +00007081
7082ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
7083 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
7084 ASTIdentifierLookupTable *IdTable
7085 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
7086 Current = IdTable->key_begin();
7087 End = IdTable->key_end();
7088}
7089
7090StringRef ASTIdentifierIterator::Next() {
7091 while (Current == End) {
7092 // If we have exhausted all of our AST files, we're done.
7093 if (Index == 0)
7094 return StringRef();
7095
7096 --Index;
7097 ASTIdentifierLookupTable *IdTable
7098 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
7099 IdentifierLookupTable;
7100 Current = IdTable->key_begin();
7101 End = IdTable->key_end();
7102 }
7103
7104 // We have any identifiers remaining in the current AST file; return
7105 // the next one.
Douglas Gregorbfd73d72013-01-23 18:53:14 +00007106 StringRef Result = *Current;
Guy Benyei11169dd2012-12-18 14:30:41 +00007107 ++Current;
Douglas Gregorbfd73d72013-01-23 18:53:14 +00007108 return Result;
Guy Benyei11169dd2012-12-18 14:30:41 +00007109}
7110
Argyrios Kyrtzidis9aca3c62013-04-17 22:10:55 +00007111IdentifierIterator *ASTReader::getIdentifiers() {
7112 if (!loadGlobalIndex())
7113 return GlobalIndex->createIdentifierIterator();
7114
Guy Benyei11169dd2012-12-18 14:30:41 +00007115 return new ASTIdentifierIterator(*this);
7116}
7117
7118namespace clang { namespace serialization {
7119 class ReadMethodPoolVisitor {
7120 ASTReader &Reader;
7121 Selector Sel;
7122 unsigned PriorGeneration;
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00007123 unsigned InstanceBits;
7124 unsigned FactoryBits;
Nico Weberff4b35e2014-12-27 22:14:15 +00007125 bool InstanceHasMoreThanOneDecl;
7126 bool FactoryHasMoreThanOneDecl;
Dmitri Gribenkof8579502013-01-12 19:30:44 +00007127 SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
7128 SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
Guy Benyei11169dd2012-12-18 14:30:41 +00007129
7130 public:
Nico Weber2e0c8f72014-12-27 03:58:08 +00007131 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
Guy Benyei11169dd2012-12-18 14:30:41 +00007132 unsigned PriorGeneration)
Nico Weber2e0c8f72014-12-27 03:58:08 +00007133 : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
Nico Weberff4b35e2014-12-27 22:14:15 +00007134 InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false),
7135 FactoryHasMoreThanOneDecl(false) {}
Nico Weber2e0c8f72014-12-27 03:58:08 +00007136
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00007137 bool operator()(ModuleFile &M) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007138 if (!M.SelectorLookupTable)
7139 return false;
7140
7141 // If we've already searched this module file, skip it now.
Richard Smithbdf2d932015-07-30 03:37:16 +00007142 if (M.Generation <= PriorGeneration)
Guy Benyei11169dd2012-12-18 14:30:41 +00007143 return true;
7144
Richard Smithbdf2d932015-07-30 03:37:16 +00007145 ++Reader.NumMethodPoolTableLookups;
Guy Benyei11169dd2012-12-18 14:30:41 +00007146 ASTSelectorLookupTable *PoolTable
7147 = (ASTSelectorLookupTable*)M.SelectorLookupTable;
Richard Smithbdf2d932015-07-30 03:37:16 +00007148 ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
Guy Benyei11169dd2012-12-18 14:30:41 +00007149 if (Pos == PoolTable->end())
7150 return false;
Douglas Gregorad2f7a52013-01-28 17:54:36 +00007151
Richard Smithbdf2d932015-07-30 03:37:16 +00007152 ++Reader.NumMethodPoolTableHits;
7153 ++Reader.NumSelectorsRead;
Guy Benyei11169dd2012-12-18 14:30:41 +00007154 // FIXME: Not quite happy with the statistics here. We probably should
7155 // disable this tracking when called via LoadSelector.
7156 // Also, should entries without methods count as misses?
Richard Smithbdf2d932015-07-30 03:37:16 +00007157 ++Reader.NumMethodPoolEntriesRead;
Guy Benyei11169dd2012-12-18 14:30:41 +00007158 ASTSelectorLookupTrait::data_type Data = *Pos;
Richard Smithbdf2d932015-07-30 03:37:16 +00007159 if (Reader.DeserializationListener)
7160 Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00007161
Richard Smithbdf2d932015-07-30 03:37:16 +00007162 InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
7163 FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
7164 InstanceBits = Data.InstanceBits;
7165 FactoryBits = Data.FactoryBits;
7166 InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
7167 FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
Guy Benyei11169dd2012-12-18 14:30:41 +00007168 return true;
7169 }
7170
7171 /// \brief Retrieve the instance methods found by this visitor.
7172 ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
7173 return InstanceMethods;
7174 }
7175
7176 /// \brief Retrieve the instance methods found by this visitor.
7177 ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
7178 return FactoryMethods;
7179 }
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00007180
7181 unsigned getInstanceBits() const { return InstanceBits; }
7182 unsigned getFactoryBits() const { return FactoryBits; }
Nico Weberff4b35e2014-12-27 22:14:15 +00007183 bool instanceHasMoreThanOneDecl() const {
7184 return InstanceHasMoreThanOneDecl;
7185 }
7186 bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
Guy Benyei11169dd2012-12-18 14:30:41 +00007187 };
Alexander Kornienkoab9db512015-06-22 23:07:51 +00007188} } // end namespace clang::serialization
Guy Benyei11169dd2012-12-18 14:30:41 +00007189
7190/// \brief Add the given set of methods to the method list.
7191static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
7192 ObjCMethodList &List) {
7193 for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
7194 S.addMethodToGlobalList(&List, Methods[I]);
7195 }
7196}
7197
7198void ASTReader::ReadMethodPool(Selector Sel) {
7199 // Get the selector generation and update it to the current generation.
7200 unsigned &Generation = SelectorGeneration[Sel];
7201 unsigned PriorGeneration = Generation;
Richard Smith053f6c62014-05-16 23:01:30 +00007202 Generation = getGeneration();
Guy Benyei11169dd2012-12-18 14:30:41 +00007203
7204 // Search for methods defined with this selector.
Douglas Gregorad2f7a52013-01-28 17:54:36 +00007205 ++NumMethodPoolLookups;
Guy Benyei11169dd2012-12-18 14:30:41 +00007206 ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
Benjamin Kramer9a9efba2015-07-25 12:14:04 +00007207 ModuleMgr.visit(Visitor);
7208
Guy Benyei11169dd2012-12-18 14:30:41 +00007209 if (Visitor.getInstanceMethods().empty() &&
Douglas Gregorad2f7a52013-01-28 17:54:36 +00007210 Visitor.getFactoryMethods().empty())
Guy Benyei11169dd2012-12-18 14:30:41 +00007211 return;
Douglas Gregorad2f7a52013-01-28 17:54:36 +00007212
7213 ++NumMethodPoolHits;
7214
Guy Benyei11169dd2012-12-18 14:30:41 +00007215 if (!getSema())
7216 return;
7217
7218 Sema &S = *getSema();
7219 Sema::GlobalMethodPool::iterator Pos
7220 = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
Ben Langmuira0c32e92015-01-12 19:27:00 +00007221
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00007222 Pos->second.first.setBits(Visitor.getInstanceBits());
Nico Weberff4b35e2014-12-27 22:14:15 +00007223 Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
Argyrios Kyrtzidisd3da6e02013-04-17 00:08:58 +00007224 Pos->second.second.setBits(Visitor.getFactoryBits());
Nico Weberff4b35e2014-12-27 22:14:15 +00007225 Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
Ben Langmuira0c32e92015-01-12 19:27:00 +00007226
7227 // Add methods to the global pool *after* setting hasMoreThanOneDecl, since
7228 // when building a module we keep every method individually and may need to
7229 // update hasMoreThanOneDecl as we add the methods.
7230 addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
7231 addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
Guy Benyei11169dd2012-12-18 14:30:41 +00007232}
7233
7234void ASTReader::ReadKnownNamespaces(
7235 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
7236 Namespaces.clear();
7237
7238 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
7239 if (NamespaceDecl *Namespace
7240 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
7241 Namespaces.push_back(Namespace);
7242 }
7243}
7244
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00007245void ASTReader::ReadUndefinedButUsed(
Richard Smithd6a04d72016-03-25 21:49:43 +00007246 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00007247 for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
7248 NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
Nick Lewycky8334af82013-01-26 00:35:08 +00007249 SourceLocation Loc =
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00007250 SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
Nick Lewycky8334af82013-01-26 00:35:08 +00007251 Undefined.insert(std::make_pair(D, Loc));
7252 }
7253}
Nick Lewycky8334af82013-01-26 00:35:08 +00007254
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00007255void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
7256 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
7257 Exprs) {
7258 for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
7259 FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
7260 uint64_t Count = DelayedDeleteExprs[Idx++];
7261 for (uint64_t C = 0; C < Count; ++C) {
7262 SourceLocation DeleteLoc =
7263 SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
7264 const bool IsArrayForm = DelayedDeleteExprs[Idx++];
7265 Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
7266 }
7267 }
7268}
7269
Guy Benyei11169dd2012-12-18 14:30:41 +00007270void ASTReader::ReadTentativeDefinitions(
7271 SmallVectorImpl<VarDecl *> &TentativeDefs) {
7272 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
7273 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
7274 if (Var)
7275 TentativeDefs.push_back(Var);
7276 }
7277 TentativeDefinitions.clear();
7278}
7279
7280void ASTReader::ReadUnusedFileScopedDecls(
7281 SmallVectorImpl<const DeclaratorDecl *> &Decls) {
7282 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
7283 DeclaratorDecl *D
7284 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
7285 if (D)
7286 Decls.push_back(D);
7287 }
7288 UnusedFileScopedDecls.clear();
7289}
7290
7291void ASTReader::ReadDelegatingConstructors(
7292 SmallVectorImpl<CXXConstructorDecl *> &Decls) {
7293 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
7294 CXXConstructorDecl *D
7295 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
7296 if (D)
7297 Decls.push_back(D);
7298 }
7299 DelegatingCtorDecls.clear();
7300}
7301
7302void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
7303 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
7304 TypedefNameDecl *D
7305 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
7306 if (D)
7307 Decls.push_back(D);
7308 }
7309 ExtVectorDecls.clear();
7310}
7311
Nico Weber72889432014-09-06 01:25:55 +00007312void ASTReader::ReadUnusedLocalTypedefNameCandidates(
7313 llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
7314 for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
7315 ++I) {
7316 TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
7317 GetDecl(UnusedLocalTypedefNameCandidates[I]));
7318 if (D)
7319 Decls.insert(D);
7320 }
7321 UnusedLocalTypedefNameCandidates.clear();
7322}
7323
Guy Benyei11169dd2012-12-18 14:30:41 +00007324void ASTReader::ReadReferencedSelectors(
7325 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
7326 if (ReferencedSelectorsData.empty())
7327 return;
7328
7329 // If there are @selector references added them to its pool. This is for
7330 // implementation of -Wselector.
7331 unsigned int DataSize = ReferencedSelectorsData.size()-1;
7332 unsigned I = 0;
7333 while (I < DataSize) {
7334 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
7335 SourceLocation SelLoc
7336 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
7337 Sels.push_back(std::make_pair(Sel, SelLoc));
7338 }
7339 ReferencedSelectorsData.clear();
7340}
7341
7342void ASTReader::ReadWeakUndeclaredIdentifiers(
7343 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
7344 if (WeakUndeclaredIdentifiers.empty())
7345 return;
7346
7347 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
7348 IdentifierInfo *WeakId
7349 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7350 IdentifierInfo *AliasId
7351 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
7352 SourceLocation Loc
7353 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
7354 bool Used = WeakUndeclaredIdentifiers[I++];
7355 WeakInfo WI(AliasId, Loc);
7356 WI.setUsed(Used);
7357 WeakIDs.push_back(std::make_pair(WeakId, WI));
7358 }
7359 WeakUndeclaredIdentifiers.clear();
7360}
7361
7362void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
7363 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
7364 ExternalVTableUse VT;
7365 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
7366 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
7367 VT.DefinitionRequired = VTableUses[Idx++];
7368 VTables.push_back(VT);
7369 }
7370
7371 VTableUses.clear();
7372}
7373
7374void ASTReader::ReadPendingInstantiations(
7375 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
7376 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
7377 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
7378 SourceLocation Loc
7379 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
7380
7381 Pending.push_back(std::make_pair(D, Loc));
7382 }
7383 PendingInstantiations.clear();
7384}
7385
Richard Smithe40f2ba2013-08-07 21:41:30 +00007386void ASTReader::ReadLateParsedTemplates(
Chandler Carruth52cee4d2015-03-26 09:08:15 +00007387 llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
Richard Smithe40f2ba2013-08-07 21:41:30 +00007388 for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
7389 /* In loop */) {
7390 FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
7391
7392 LateParsedTemplate *LT = new LateParsedTemplate;
7393 LT->D = GetDecl(LateParsedTemplates[Idx++]);
7394
7395 ModuleFile *F = getOwningModuleFile(LT->D);
7396 assert(F && "No module");
7397
7398 unsigned TokN = LateParsedTemplates[Idx++];
7399 LT->Toks.reserve(TokN);
7400 for (unsigned T = 0; T < TokN; ++T)
7401 LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
7402
Chandler Carruth52cee4d2015-03-26 09:08:15 +00007403 LPTMap.insert(std::make_pair(FD, LT));
Richard Smithe40f2ba2013-08-07 21:41:30 +00007404 }
7405
7406 LateParsedTemplates.clear();
7407}
7408
Guy Benyei11169dd2012-12-18 14:30:41 +00007409void ASTReader::LoadSelector(Selector Sel) {
7410 // It would be complicated to avoid reading the methods anyway. So don't.
7411 ReadMethodPool(Sel);
7412}
7413
7414void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
7415 assert(ID && "Non-zero identifier ID required");
7416 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
7417 IdentifiersLoaded[ID - 1] = II;
7418 if (DeserializationListener)
7419 DeserializationListener->IdentifierRead(ID, II);
7420}
7421
7422/// \brief Set the globally-visible declarations associated with the given
7423/// identifier.
7424///
7425/// If the AST reader is currently in a state where the given declaration IDs
7426/// cannot safely be resolved, they are queued until it is safe to resolve
7427/// them.
7428///
7429/// \param II an IdentifierInfo that refers to one or more globally-visible
7430/// declarations.
7431///
7432/// \param DeclIDs the set of declaration IDs with the name @p II that are
7433/// visible at global scope.
7434///
Douglas Gregor6168bd22013-02-18 15:53:43 +00007435/// \param Decls if non-null, this vector will be populated with the set of
7436/// deserialized declarations. These declarations will not be pushed into
7437/// scope.
Guy Benyei11169dd2012-12-18 14:30:41 +00007438void
7439ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
7440 const SmallVectorImpl<uint32_t> &DeclIDs,
Douglas Gregor6168bd22013-02-18 15:53:43 +00007441 SmallVectorImpl<Decl *> *Decls) {
7442 if (NumCurrentElementsDeserializing && !Decls) {
7443 PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
Guy Benyei11169dd2012-12-18 14:30:41 +00007444 return;
7445 }
7446
7447 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
Ben Langmuir5418f402014-09-10 21:29:41 +00007448 if (!SemaObj) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007449 // Queue this declaration so that it will be added to the
7450 // translation unit scope and identifier's declaration chain
7451 // once a Sema object is known.
Ben Langmuir5418f402014-09-10 21:29:41 +00007452 PreloadedDeclIDs.push_back(DeclIDs[I]);
7453 continue;
Guy Benyei11169dd2012-12-18 14:30:41 +00007454 }
Ben Langmuir5418f402014-09-10 21:29:41 +00007455
7456 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
7457
7458 // If we're simply supposed to record the declarations, do so now.
7459 if (Decls) {
7460 Decls->push_back(D);
7461 continue;
7462 }
7463
7464 // Introduce this declaration into the translation-unit scope
7465 // and add it to the declaration chain for this identifier, so
7466 // that (unqualified) name lookup will find it.
7467 pushExternalDeclIntoScope(D, II);
Guy Benyei11169dd2012-12-18 14:30:41 +00007468 }
7469}
7470
Douglas Gregorc8a992f2013-01-21 16:52:34 +00007471IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007472 if (ID == 0)
Craig Toppera13603a2014-05-22 05:54:18 +00007473 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007474
7475 if (IdentifiersLoaded.empty()) {
7476 Error("no identifier table in AST file");
Craig Toppera13603a2014-05-22 05:54:18 +00007477 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007478 }
7479
7480 ID -= 1;
7481 if (!IdentifiersLoaded[ID]) {
7482 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
7483 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
7484 ModuleFile *M = I->second;
7485 unsigned Index = ID - M->BaseIdentifierID;
7486 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
7487
7488 // All of the strings in the AST file are preceded by a 16-bit length.
7489 // Extract that 16-bit length to avoid having to execute strlen().
7490 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as
7491 // unsigned integers. This is important to avoid integer overflow when
7492 // we cast them to 'unsigned'.
7493 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
7494 unsigned StrLen = (((unsigned) StrLenPtr[0])
7495 | (((unsigned) StrLenPtr[1]) << 8)) - 1;
Richard Smitheb4b58f62016-02-05 01:40:54 +00007496 auto &II = PP.getIdentifierTable().get(StringRef(Str, StrLen));
7497 IdentifiersLoaded[ID] = &II;
7498 markIdentifierFromAST(*this, II);
Guy Benyei11169dd2012-12-18 14:30:41 +00007499 if (DeserializationListener)
Richard Smitheb4b58f62016-02-05 01:40:54 +00007500 DeserializationListener->IdentifierRead(ID + 1, &II);
Guy Benyei11169dd2012-12-18 14:30:41 +00007501 }
7502
7503 return IdentifiersLoaded[ID];
7504}
7505
Douglas Gregorc8a992f2013-01-21 16:52:34 +00007506IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
7507 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
Guy Benyei11169dd2012-12-18 14:30:41 +00007508}
7509
7510IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
7511 if (LocalID < NUM_PREDEF_IDENT_IDS)
7512 return LocalID;
7513
7514 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7515 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
7516 assert(I != M.IdentifierRemap.end()
7517 && "Invalid index into identifier index remap");
7518
7519 return LocalID + I->second;
7520}
7521
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00007522MacroInfo *ASTReader::getMacro(MacroID ID) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007523 if (ID == 0)
Craig Toppera13603a2014-05-22 05:54:18 +00007524 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007525
7526 if (MacrosLoaded.empty()) {
7527 Error("no macro table in AST file");
Craig Toppera13603a2014-05-22 05:54:18 +00007528 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007529 }
7530
7531 ID -= NUM_PREDEF_MACRO_IDS;
7532 if (!MacrosLoaded[ID]) {
7533 GlobalMacroMapType::iterator I
7534 = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
7535 assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
7536 ModuleFile *M = I->second;
7537 unsigned Index = ID - M->BaseMacroID;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00007538 MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
7539
7540 if (DeserializationListener)
7541 DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
7542 MacrosLoaded[ID]);
Guy Benyei11169dd2012-12-18 14:30:41 +00007543 }
7544
7545 return MacrosLoaded[ID];
7546}
7547
7548MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
7549 if (LocalID < NUM_PREDEF_MACRO_IDS)
7550 return LocalID;
7551
7552 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7553 = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
7554 assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
7555
7556 return LocalID + I->second;
7557}
7558
7559serialization::SubmoduleID
7560ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
7561 if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
7562 return LocalID;
7563
7564 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7565 = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
7566 assert(I != M.SubmoduleRemap.end()
7567 && "Invalid index into submodule index remap");
7568
7569 return LocalID + I->second;
7570}
7571
7572Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
7573 if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
7574 assert(GlobalID == 0 && "Unhandled global submodule ID");
Craig Toppera13603a2014-05-22 05:54:18 +00007575 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007576 }
7577
7578 if (GlobalID > SubmodulesLoaded.size()) {
7579 Error("submodule ID out of range in AST file");
Craig Toppera13603a2014-05-22 05:54:18 +00007580 return nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007581 }
7582
7583 return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
7584}
Douglas Gregorc147b0b2013-01-12 01:29:50 +00007585
7586Module *ASTReader::getModule(unsigned ID) {
7587 return getSubmodule(ID);
7588}
7589
Richard Smithd88a7f12015-09-01 20:35:42 +00007590ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
7591 if (ID & 1) {
7592 // It's a module, look it up by submodule ID.
7593 auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
7594 return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
7595 } else {
7596 // It's a prefix (preamble, PCH, ...). Look it up by index.
7597 unsigned IndexFromEnd = ID >> 1;
7598 assert(IndexFromEnd && "got reference to unknown module file");
7599 return getModuleManager().pch_modules().end()[-IndexFromEnd];
7600 }
7601}
7602
7603unsigned ASTReader::getModuleFileID(ModuleFile *F) {
7604 if (!F)
7605 return 1;
7606
7607 // For a file representing a module, use the submodule ID of the top-level
7608 // module as the file ID. For any other kind of file, the number of such
7609 // files loaded beforehand will be the same on reload.
7610 // FIXME: Is this true even if we have an explicit module file and a PCH?
7611 if (F->isModule())
7612 return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
7613
7614 auto PCHModules = getModuleManager().pch_modules();
7615 auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
7616 assert(I != PCHModules.end() && "emitting reference to unknown file");
7617 return (I - PCHModules.end()) << 1;
7618}
7619
Adrian Prantl15bcf702015-06-30 17:39:43 +00007620llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
7621ASTReader::getSourceDescriptor(unsigned ID) {
7622 if (const Module *M = getSubmodule(ID))
Adrian Prantlc6458d62015-09-19 00:10:32 +00007623 return ExternalASTSource::ASTSourceDescriptor(*M);
Adrian Prantl15bcf702015-06-30 17:39:43 +00007624
7625 // If there is only a single PCH, return it instead.
7626 // Chained PCH are not suported.
7627 if (ModuleMgr.size() == 1) {
7628 ModuleFile &MF = ModuleMgr.getPrimaryModule();
Adrian Prantl3a2d4942016-01-22 23:30:56 +00007629 StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
7630 return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir,
7631 MF.FileName, MF.Signature);
Adrian Prantl15bcf702015-06-30 17:39:43 +00007632 }
7633 return None;
7634}
7635
Guy Benyei11169dd2012-12-18 14:30:41 +00007636Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
7637 return DecodeSelector(getGlobalSelectorID(M, LocalID));
7638}
7639
7640Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
7641 if (ID == 0)
7642 return Selector();
7643
7644 if (ID > SelectorsLoaded.size()) {
7645 Error("selector ID out of range in AST file");
7646 return Selector();
7647 }
7648
Craig Toppera13603a2014-05-22 05:54:18 +00007649 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007650 // Load this selector from the selector table.
7651 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
7652 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
7653 ModuleFile &M = *I->second;
7654 ASTSelectorLookupTrait Trait(*this, M);
7655 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
7656 SelectorsLoaded[ID - 1] =
7657 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
7658 if (DeserializationListener)
7659 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
7660 }
7661
7662 return SelectorsLoaded[ID - 1];
7663}
7664
7665Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
7666 return DecodeSelector(ID);
7667}
7668
7669uint32_t ASTReader::GetNumExternalSelectors() {
7670 // ID 0 (the null selector) is considered an external selector.
7671 return getTotalNumSelectors() + 1;
7672}
7673
7674serialization::SelectorID
7675ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
7676 if (LocalID < NUM_PREDEF_SELECTOR_IDS)
7677 return LocalID;
7678
7679 ContinuousRangeMap<uint32_t, int, 2>::iterator I
7680 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
7681 assert(I != M.SelectorRemap.end()
7682 && "Invalid index into selector index remap");
7683
7684 return LocalID + I->second;
7685}
7686
7687DeclarationName
7688ASTReader::ReadDeclarationName(ModuleFile &F,
7689 const RecordData &Record, unsigned &Idx) {
7690 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
7691 switch (Kind) {
7692 case DeclarationName::Identifier:
Douglas Gregorc8a992f2013-01-21 16:52:34 +00007693 return DeclarationName(GetIdentifierInfo(F, Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00007694
7695 case DeclarationName::ObjCZeroArgSelector:
7696 case DeclarationName::ObjCOneArgSelector:
7697 case DeclarationName::ObjCMultiArgSelector:
7698 return DeclarationName(ReadSelector(F, Record, Idx));
7699
7700 case DeclarationName::CXXConstructorName:
7701 return Context.DeclarationNames.getCXXConstructorName(
7702 Context.getCanonicalType(readType(F, Record, Idx)));
7703
7704 case DeclarationName::CXXDestructorName:
7705 return Context.DeclarationNames.getCXXDestructorName(
7706 Context.getCanonicalType(readType(F, Record, Idx)));
7707
7708 case DeclarationName::CXXConversionFunctionName:
7709 return Context.DeclarationNames.getCXXConversionFunctionName(
7710 Context.getCanonicalType(readType(F, Record, Idx)));
7711
7712 case DeclarationName::CXXOperatorName:
7713 return Context.DeclarationNames.getCXXOperatorName(
7714 (OverloadedOperatorKind)Record[Idx++]);
7715
7716 case DeclarationName::CXXLiteralOperatorName:
7717 return Context.DeclarationNames.getCXXLiteralOperatorName(
7718 GetIdentifierInfo(F, Record, Idx));
7719
7720 case DeclarationName::CXXUsingDirective:
7721 return DeclarationName::getUsingDirectiveName();
7722 }
7723
7724 llvm_unreachable("Invalid NameKind!");
7725}
7726
7727void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
7728 DeclarationNameLoc &DNLoc,
7729 DeclarationName Name,
7730 const RecordData &Record, unsigned &Idx) {
7731 switch (Name.getNameKind()) {
7732 case DeclarationName::CXXConstructorName:
7733 case DeclarationName::CXXDestructorName:
7734 case DeclarationName::CXXConversionFunctionName:
7735 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
7736 break;
7737
7738 case DeclarationName::CXXOperatorName:
7739 DNLoc.CXXOperatorName.BeginOpNameLoc
7740 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7741 DNLoc.CXXOperatorName.EndOpNameLoc
7742 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7743 break;
7744
7745 case DeclarationName::CXXLiteralOperatorName:
7746 DNLoc.CXXLiteralOperatorName.OpNameLoc
7747 = ReadSourceLocation(F, Record, Idx).getRawEncoding();
7748 break;
7749
7750 case DeclarationName::Identifier:
7751 case DeclarationName::ObjCZeroArgSelector:
7752 case DeclarationName::ObjCOneArgSelector:
7753 case DeclarationName::ObjCMultiArgSelector:
7754 case DeclarationName::CXXUsingDirective:
7755 break;
7756 }
7757}
7758
7759void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
7760 DeclarationNameInfo &NameInfo,
7761 const RecordData &Record, unsigned &Idx) {
7762 NameInfo.setName(ReadDeclarationName(F, Record, Idx));
7763 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
7764 DeclarationNameLoc DNLoc;
7765 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
7766 NameInfo.setInfo(DNLoc);
7767}
7768
7769void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
7770 const RecordData &Record, unsigned &Idx) {
7771 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
7772 unsigned NumTPLists = Record[Idx++];
7773 Info.NumTemplParamLists = NumTPLists;
7774 if (NumTPLists) {
7775 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
7776 for (unsigned i=0; i != NumTPLists; ++i)
7777 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
7778 }
7779}
7780
7781TemplateName
7782ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
7783 unsigned &Idx) {
7784 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
7785 switch (Kind) {
7786 case TemplateName::Template:
7787 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
7788
7789 case TemplateName::OverloadedTemplate: {
7790 unsigned size = Record[Idx++];
7791 UnresolvedSet<8> Decls;
7792 while (size--)
7793 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
7794
7795 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
7796 }
7797
7798 case TemplateName::QualifiedTemplate: {
7799 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7800 bool hasTemplKeyword = Record[Idx++];
7801 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
7802 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
7803 }
7804
7805 case TemplateName::DependentTemplate: {
7806 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
7807 if (Record[Idx++]) // isIdentifier
7808 return Context.getDependentTemplateName(NNS,
7809 GetIdentifierInfo(F, Record,
7810 Idx));
7811 return Context.getDependentTemplateName(NNS,
7812 (OverloadedOperatorKind)Record[Idx++]);
7813 }
7814
7815 case TemplateName::SubstTemplateTemplateParm: {
7816 TemplateTemplateParmDecl *param
7817 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7818 if (!param) return TemplateName();
7819 TemplateName replacement = ReadTemplateName(F, Record, Idx);
7820 return Context.getSubstTemplateTemplateParm(param, replacement);
7821 }
7822
7823 case TemplateName::SubstTemplateTemplateParmPack: {
7824 TemplateTemplateParmDecl *Param
7825 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
7826 if (!Param)
7827 return TemplateName();
7828
7829 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
7830 if (ArgPack.getKind() != TemplateArgument::Pack)
7831 return TemplateName();
7832
7833 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
7834 }
7835 }
7836
7837 llvm_unreachable("Unhandled template name kind!");
7838}
7839
Richard Smith2bb3c342015-08-09 01:05:31 +00007840TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
7841 const RecordData &Record,
7842 unsigned &Idx,
7843 bool Canonicalize) {
7844 if (Canonicalize) {
7845 // The caller wants a canonical template argument. Sometimes the AST only
7846 // wants template arguments in canonical form (particularly as the template
7847 // argument lists of template specializations) so ensure we preserve that
7848 // canonical form across serialization.
7849 TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
7850 return Context.getCanonicalTemplateArgument(Arg);
7851 }
7852
Guy Benyei11169dd2012-12-18 14:30:41 +00007853 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
7854 switch (Kind) {
7855 case TemplateArgument::Null:
7856 return TemplateArgument();
7857 case TemplateArgument::Type:
7858 return TemplateArgument(readType(F, Record, Idx));
7859 case TemplateArgument::Declaration: {
7860 ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
David Blaikie0f62c8d2014-10-16 04:21:25 +00007861 return TemplateArgument(D, readType(F, Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00007862 }
7863 case TemplateArgument::NullPtr:
7864 return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
7865 case TemplateArgument::Integral: {
7866 llvm::APSInt Value = ReadAPSInt(Record, Idx);
7867 QualType T = readType(F, Record, Idx);
7868 return TemplateArgument(Context, Value, T);
7869 }
7870 case TemplateArgument::Template:
7871 return TemplateArgument(ReadTemplateName(F, Record, Idx));
7872 case TemplateArgument::TemplateExpansion: {
7873 TemplateName Name = ReadTemplateName(F, Record, Idx);
David Blaikie05785d12013-02-20 22:23:23 +00007874 Optional<unsigned> NumTemplateExpansions;
Guy Benyei11169dd2012-12-18 14:30:41 +00007875 if (unsigned NumExpansions = Record[Idx++])
7876 NumTemplateExpansions = NumExpansions - 1;
7877 return TemplateArgument(Name, NumTemplateExpansions);
7878 }
7879 case TemplateArgument::Expression:
7880 return TemplateArgument(ReadExpr(F));
7881 case TemplateArgument::Pack: {
7882 unsigned NumArgs = Record[Idx++];
7883 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
7884 for (unsigned I = 0; I != NumArgs; ++I)
7885 Args[I] = ReadTemplateArgument(F, Record, Idx);
Benjamin Kramercce63472015-08-05 09:40:22 +00007886 return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
Guy Benyei11169dd2012-12-18 14:30:41 +00007887 }
7888 }
7889
7890 llvm_unreachable("Unhandled template argument kind!");
7891}
7892
7893TemplateParameterList *
7894ASTReader::ReadTemplateParameterList(ModuleFile &F,
7895 const RecordData &Record, unsigned &Idx) {
7896 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
7897 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
7898 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
7899
7900 unsigned NumParams = Record[Idx++];
7901 SmallVector<NamedDecl *, 16> Params;
7902 Params.reserve(NumParams);
7903 while (NumParams--)
7904 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
7905
7906 TemplateParameterList* TemplateParams =
7907 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
David Majnemer902f8c62015-12-27 07:16:27 +00007908 Params, RAngleLoc);
Guy Benyei11169dd2012-12-18 14:30:41 +00007909 return TemplateParams;
7910}
7911
7912void
7913ASTReader::
Craig Topper5603df42013-07-05 19:34:19 +00007914ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
Guy Benyei11169dd2012-12-18 14:30:41 +00007915 ModuleFile &F, const RecordData &Record,
Richard Smith2bb3c342015-08-09 01:05:31 +00007916 unsigned &Idx, bool Canonicalize) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007917 unsigned NumTemplateArgs = Record[Idx++];
7918 TemplArgs.reserve(NumTemplateArgs);
7919 while (NumTemplateArgs--)
Richard Smith2bb3c342015-08-09 01:05:31 +00007920 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
Guy Benyei11169dd2012-12-18 14:30:41 +00007921}
7922
7923/// \brief Read a UnresolvedSet structure.
Richard Smitha4ba74c2013-08-30 04:46:40 +00007924void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
Guy Benyei11169dd2012-12-18 14:30:41 +00007925 const RecordData &Record, unsigned &Idx) {
7926 unsigned NumDecls = Record[Idx++];
7927 Set.reserve(Context, NumDecls);
7928 while (NumDecls--) {
Richard Smitha4ba74c2013-08-30 04:46:40 +00007929 DeclID ID = ReadDeclID(F, Record, Idx);
Guy Benyei11169dd2012-12-18 14:30:41 +00007930 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
Richard Smitha4ba74c2013-08-30 04:46:40 +00007931 Set.addLazyDecl(Context, ID, AS);
Guy Benyei11169dd2012-12-18 14:30:41 +00007932 }
7933}
7934
7935CXXBaseSpecifier
7936ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
7937 const RecordData &Record, unsigned &Idx) {
7938 bool isVirtual = static_cast<bool>(Record[Idx++]);
7939 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
7940 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
7941 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
7942 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
7943 SourceRange Range = ReadSourceRange(F, Record, Idx);
7944 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
7945 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
7946 EllipsisLoc);
7947 Result.setInheritConstructors(inheritConstructors);
7948 return Result;
7949}
7950
Richard Smithc2bb8182015-03-24 06:36:48 +00007951CXXCtorInitializer **
Guy Benyei11169dd2012-12-18 14:30:41 +00007952ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
7953 unsigned &Idx) {
Guy Benyei11169dd2012-12-18 14:30:41 +00007954 unsigned NumInitializers = Record[Idx++];
Richard Smithc2bb8182015-03-24 06:36:48 +00007955 assert(NumInitializers && "wrote ctor initializers but have no inits");
7956 auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
7957 for (unsigned i = 0; i != NumInitializers; ++i) {
7958 TypeSourceInfo *TInfo = nullptr;
7959 bool IsBaseVirtual = false;
7960 FieldDecl *Member = nullptr;
7961 IndirectFieldDecl *IndirectMember = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00007962
Richard Smithc2bb8182015-03-24 06:36:48 +00007963 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
7964 switch (Type) {
7965 case CTOR_INITIALIZER_BASE:
7966 TInfo = GetTypeSourceInfo(F, Record, Idx);
7967 IsBaseVirtual = Record[Idx++];
7968 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00007969
Richard Smithc2bb8182015-03-24 06:36:48 +00007970 case CTOR_INITIALIZER_DELEGATING:
7971 TInfo = GetTypeSourceInfo(F, Record, Idx);
7972 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00007973
Richard Smithc2bb8182015-03-24 06:36:48 +00007974 case CTOR_INITIALIZER_MEMBER:
7975 Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
7976 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00007977
Richard Smithc2bb8182015-03-24 06:36:48 +00007978 case CTOR_INITIALIZER_INDIRECT_MEMBER:
7979 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
7980 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00007981 }
Richard Smithc2bb8182015-03-24 06:36:48 +00007982
7983 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
7984 Expr *Init = ReadExpr(F);
7985 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
7986 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
7987 bool IsWritten = Record[Idx++];
7988 unsigned SourceOrderOrNumArrayIndices;
7989 SmallVector<VarDecl *, 8> Indices;
7990 if (IsWritten) {
7991 SourceOrderOrNumArrayIndices = Record[Idx++];
7992 } else {
7993 SourceOrderOrNumArrayIndices = Record[Idx++];
7994 Indices.reserve(SourceOrderOrNumArrayIndices);
7995 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
7996 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
7997 }
7998
7999 CXXCtorInitializer *BOMInit;
8000 if (Type == CTOR_INITIALIZER_BASE) {
8001 BOMInit = new (Context)
8002 CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
8003 RParenLoc, MemberOrEllipsisLoc);
8004 } else if (Type == CTOR_INITIALIZER_DELEGATING) {
8005 BOMInit = new (Context)
8006 CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
8007 } else if (IsWritten) {
8008 if (Member)
8009 BOMInit = new (Context) CXXCtorInitializer(
8010 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc);
8011 else
8012 BOMInit = new (Context)
8013 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8014 LParenLoc, Init, RParenLoc);
8015 } else {
8016 if (IndirectMember) {
8017 assert(Indices.empty() && "Indirect field improperly initialized");
8018 BOMInit = new (Context)
8019 CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
8020 LParenLoc, Init, RParenLoc);
8021 } else {
8022 BOMInit = CXXCtorInitializer::Create(
8023 Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc,
8024 Indices.data(), Indices.size());
8025 }
8026 }
8027
8028 if (IsWritten)
8029 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
8030 CtorInitializers[i] = BOMInit;
Guy Benyei11169dd2012-12-18 14:30:41 +00008031 }
8032
Richard Smithc2bb8182015-03-24 06:36:48 +00008033 return CtorInitializers;
Guy Benyei11169dd2012-12-18 14:30:41 +00008034}
8035
8036NestedNameSpecifier *
8037ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
8038 const RecordData &Record, unsigned &Idx) {
8039 unsigned N = Record[Idx++];
Craig Toppera13603a2014-05-22 05:54:18 +00008040 NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
Guy Benyei11169dd2012-12-18 14:30:41 +00008041 for (unsigned I = 0; I != N; ++I) {
8042 NestedNameSpecifier::SpecifierKind Kind
8043 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8044 switch (Kind) {
8045 case NestedNameSpecifier::Identifier: {
8046 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8047 NNS = NestedNameSpecifier::Create(Context, Prev, II);
8048 break;
8049 }
8050
8051 case NestedNameSpecifier::Namespace: {
8052 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8053 NNS = NestedNameSpecifier::Create(Context, Prev, NS);
8054 break;
8055 }
8056
8057 case NestedNameSpecifier::NamespaceAlias: {
8058 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8059 NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
8060 break;
8061 }
8062
8063 case NestedNameSpecifier::TypeSpec:
8064 case NestedNameSpecifier::TypeSpecWithTemplate: {
8065 const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
8066 if (!T)
Craig Toppera13603a2014-05-22 05:54:18 +00008067 return nullptr;
8068
Guy Benyei11169dd2012-12-18 14:30:41 +00008069 bool Template = Record[Idx++];
8070 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
8071 break;
8072 }
8073
8074 case NestedNameSpecifier::Global: {
8075 NNS = NestedNameSpecifier::GlobalSpecifier(Context);
8076 // No associated value, and there can't be a prefix.
8077 break;
8078 }
Nikola Smiljanic67860242014-09-26 00:28:20 +00008079
8080 case NestedNameSpecifier::Super: {
8081 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8082 NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
8083 break;
8084 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008085 }
8086 Prev = NNS;
8087 }
8088 return NNS;
8089}
8090
8091NestedNameSpecifierLoc
8092ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
8093 unsigned &Idx) {
8094 unsigned N = Record[Idx++];
8095 NestedNameSpecifierLocBuilder Builder;
8096 for (unsigned I = 0; I != N; ++I) {
8097 NestedNameSpecifier::SpecifierKind Kind
8098 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
8099 switch (Kind) {
8100 case NestedNameSpecifier::Identifier: {
8101 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
8102 SourceRange Range = ReadSourceRange(F, Record, Idx);
8103 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
8104 break;
8105 }
8106
8107 case NestedNameSpecifier::Namespace: {
8108 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
8109 SourceRange Range = ReadSourceRange(F, Record, Idx);
8110 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
8111 break;
8112 }
8113
8114 case NestedNameSpecifier::NamespaceAlias: {
8115 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
8116 SourceRange Range = ReadSourceRange(F, Record, Idx);
8117 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
8118 break;
8119 }
8120
8121 case NestedNameSpecifier::TypeSpec:
8122 case NestedNameSpecifier::TypeSpecWithTemplate: {
8123 bool Template = Record[Idx++];
8124 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
8125 if (!T)
8126 return NestedNameSpecifierLoc();
8127 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8128
8129 // FIXME: 'template' keyword location not saved anywhere, so we fake it.
8130 Builder.Extend(Context,
8131 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
8132 T->getTypeLoc(), ColonColonLoc);
8133 break;
8134 }
8135
8136 case NestedNameSpecifier::Global: {
8137 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
8138 Builder.MakeGlobal(Context, ColonColonLoc);
8139 break;
8140 }
Nikola Smiljanic67860242014-09-26 00:28:20 +00008141
8142 case NestedNameSpecifier::Super: {
8143 CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
8144 SourceRange Range = ReadSourceRange(F, Record, Idx);
8145 Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
8146 break;
8147 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008148 }
8149 }
Nikola Smiljanic67860242014-09-26 00:28:20 +00008150
Guy Benyei11169dd2012-12-18 14:30:41 +00008151 return Builder.getWithLocInContext(Context);
8152}
8153
8154SourceRange
8155ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
8156 unsigned &Idx) {
8157 SourceLocation beg = ReadSourceLocation(F, Record, Idx);
8158 SourceLocation end = ReadSourceLocation(F, Record, Idx);
8159 return SourceRange(beg, end);
8160}
8161
8162/// \brief Read an integral value
8163llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) {
8164 unsigned BitWidth = Record[Idx++];
8165 unsigned NumWords = llvm::APInt::getNumWords(BitWidth);
8166 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
8167 Idx += NumWords;
8168 return Result;
8169}
8170
8171/// \brief Read a signed integral value
8172llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
8173 bool isUnsigned = Record[Idx++];
8174 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
8175}
8176
8177/// \brief Read a floating-point value
Tim Northover178723a2013-01-22 09:46:51 +00008178llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
8179 const llvm::fltSemantics &Sem,
8180 unsigned &Idx) {
8181 return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
Guy Benyei11169dd2012-12-18 14:30:41 +00008182}
8183
8184// \brief Read a string
8185std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
8186 unsigned Len = Record[Idx++];
8187 std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
8188 Idx += Len;
8189 return Result;
8190}
8191
Richard Smith7ed1bc92014-12-05 22:42:13 +00008192std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
8193 unsigned &Idx) {
8194 std::string Filename = ReadString(Record, Idx);
8195 ResolveImportedPath(F, Filename);
8196 return Filename;
8197}
8198
Guy Benyei11169dd2012-12-18 14:30:41 +00008199VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
8200 unsigned &Idx) {
8201 unsigned Major = Record[Idx++];
8202 unsigned Minor = Record[Idx++];
8203 unsigned Subminor = Record[Idx++];
8204 if (Minor == 0)
8205 return VersionTuple(Major);
8206 if (Subminor == 0)
8207 return VersionTuple(Major, Minor - 1);
8208 return VersionTuple(Major, Minor - 1, Subminor - 1);
8209}
8210
8211CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
8212 const RecordData &Record,
8213 unsigned &Idx) {
8214 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
8215 return CXXTemporary::Create(Context, Decl);
8216}
8217
8218DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
Argyrios Kyrtzidisdc9fdaf2013-05-24 05:44:08 +00008219 return Diag(CurrentImportLoc, DiagID);
Guy Benyei11169dd2012-12-18 14:30:41 +00008220}
8221
8222DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
8223 return Diags.Report(Loc, DiagID);
8224}
8225
8226/// \brief Retrieve the identifier table associated with the
8227/// preprocessor.
8228IdentifierTable &ASTReader::getIdentifierTable() {
8229 return PP.getIdentifierTable();
8230}
8231
8232/// \brief Record that the given ID maps to the given switch-case
8233/// statement.
8234void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
Craig Toppera13603a2014-05-22 05:54:18 +00008235 assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
Guy Benyei11169dd2012-12-18 14:30:41 +00008236 "Already have a SwitchCase with this ID");
8237 (*CurrSwitchCaseStmts)[ID] = SC;
8238}
8239
8240/// \brief Retrieve the switch-case statement with the given ID.
8241SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
Craig Toppera13603a2014-05-22 05:54:18 +00008242 assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
Guy Benyei11169dd2012-12-18 14:30:41 +00008243 return (*CurrSwitchCaseStmts)[ID];
8244}
8245
8246void ASTReader::ClearSwitchCaseIDs() {
8247 CurrSwitchCaseStmts->clear();
8248}
8249
8250void ASTReader::ReadComments() {
8251 std::vector<RawComment *> Comments;
Chris Lattner7fb3bef2013-01-20 00:56:42 +00008252 for (SmallVectorImpl<std::pair<BitstreamCursor,
Guy Benyei11169dd2012-12-18 14:30:41 +00008253 serialization::ModuleFile *> >::iterator
8254 I = CommentsCursors.begin(),
8255 E = CommentsCursors.end();
8256 I != E; ++I) {
Dmitri Gribenko9ee0e302014-03-27 15:40:39 +00008257 Comments.clear();
Chris Lattner7fb3bef2013-01-20 00:56:42 +00008258 BitstreamCursor &Cursor = I->first;
Guy Benyei11169dd2012-12-18 14:30:41 +00008259 serialization::ModuleFile &F = *I->second;
8260 SavedStreamPosition SavedPosition(Cursor);
8261
8262 RecordData Record;
8263 while (true) {
Chris Lattner7fb3bef2013-01-20 00:56:42 +00008264 llvm::BitstreamEntry Entry =
8265 Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
Dmitri Gribenko9ee0e302014-03-27 15:40:39 +00008266
Chris Lattner7fb3bef2013-01-20 00:56:42 +00008267 switch (Entry.Kind) {
8268 case llvm::BitstreamEntry::SubBlock: // Handled for us already.
8269 case llvm::BitstreamEntry::Error:
8270 Error("malformed block record in AST file");
8271 return;
8272 case llvm::BitstreamEntry::EndBlock:
8273 goto NextCursor;
8274 case llvm::BitstreamEntry::Record:
8275 // The interesting case.
Guy Benyei11169dd2012-12-18 14:30:41 +00008276 break;
Guy Benyei11169dd2012-12-18 14:30:41 +00008277 }
8278
8279 // Read a record.
8280 Record.clear();
Chris Lattner0e6c9402013-01-20 02:38:54 +00008281 switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00008282 case COMMENTS_RAW_COMMENT: {
8283 unsigned Idx = 0;
8284 SourceRange SR = ReadSourceRange(F, Record, Idx);
8285 RawComment::CommentKind Kind =
8286 (RawComment::CommentKind) Record[Idx++];
8287 bool IsTrailingComment = Record[Idx++];
8288 bool IsAlmostTrailingComment = Record[Idx++];
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +00008289 Comments.push_back(new (Context) RawComment(
8290 SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
8291 Context.getLangOpts().CommentOpts.ParseAllComments));
Guy Benyei11169dd2012-12-18 14:30:41 +00008292 break;
8293 }
8294 }
8295 }
Dmitri Gribenko9ee0e302014-03-27 15:40:39 +00008296 NextCursor:
8297 Context.Comments.addDeserializedComments(Comments);
Guy Benyei11169dd2012-12-18 14:30:41 +00008298 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008299}
8300
Richard Smithcd45dbc2014-04-19 03:48:30 +00008301std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
8302 // If we know the owning module, use it.
Richard Smith42413142015-05-15 20:05:43 +00008303 if (Module *M = D->getImportedOwningModule())
Richard Smithcd45dbc2014-04-19 03:48:30 +00008304 return M->getFullModuleName();
8305
8306 // Otherwise, use the name of the top-level module the decl is within.
8307 if (ModuleFile *M = getOwningModuleFile(D))
8308 return M->ModuleName;
8309
8310 // Not from a module.
8311 return "";
8312}
8313
Guy Benyei11169dd2012-12-18 14:30:41 +00008314void ASTReader::finishPendingActions() {
Richard Smith851072e2014-05-19 20:59:20 +00008315 while (!PendingIdentifierInfos.empty() ||
8316 !PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
Richard Smith2b9e3e32013-10-18 06:05:18 +00008317 !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
Richard Smitha0ce9c42014-07-29 23:23:27 +00008318 !PendingUpdateRecords.empty()) {
Guy Benyei11169dd2012-12-18 14:30:41 +00008319 // If any identifiers with corresponding top-level declarations have
8320 // been loaded, load those declarations now.
Craig Topper79be4cd2013-07-05 04:33:53 +00008321 typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
8322 TopLevelDeclsMap;
8323 TopLevelDeclsMap TopLevelDecls;
8324
Guy Benyei11169dd2012-12-18 14:30:41 +00008325 while (!PendingIdentifierInfos.empty()) {
Douglas Gregor6168bd22013-02-18 15:53:43 +00008326 IdentifierInfo *II = PendingIdentifierInfos.back().first;
Richard Smithf0ae3c2d2014-03-28 17:31:23 +00008327 SmallVector<uint32_t, 4> DeclIDs =
8328 std::move(PendingIdentifierInfos.back().second);
Douglas Gregorcb15f082013-02-19 18:26:28 +00008329 PendingIdentifierInfos.pop_back();
Douglas Gregor6168bd22013-02-18 15:53:43 +00008330
8331 SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
Guy Benyei11169dd2012-12-18 14:30:41 +00008332 }
Richard Smithf0ae3c2d2014-03-28 17:31:23 +00008333
Richard Smith851072e2014-05-19 20:59:20 +00008334 // For each decl chain that we wanted to complete while deserializing, mark
8335 // it as "still needs to be completed".
8336 for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
8337 markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
8338 }
8339 PendingIncompleteDeclChains.clear();
8340
Guy Benyei11169dd2012-12-18 14:30:41 +00008341 // Load pending declaration chains.
Richard Smithd8a83712015-08-22 01:47:18 +00008342 for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
Richard Smithd61d4ac2015-08-22 20:13:39 +00008343 loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
Guy Benyei11169dd2012-12-18 14:30:41 +00008344 PendingDeclChains.clear();
8345
Douglas Gregor6168bd22013-02-18 15:53:43 +00008346 // Make the most recent of the top-level declarations visible.
Craig Topper79be4cd2013-07-05 04:33:53 +00008347 for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
8348 TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
Douglas Gregor6168bd22013-02-18 15:53:43 +00008349 IdentifierInfo *II = TLD->first;
8350 for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
Argyrios Kyrtzidise5edbf92013-04-26 21:33:35 +00008351 pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
Douglas Gregor6168bd22013-02-18 15:53:43 +00008352 }
8353 }
8354
Guy Benyei11169dd2012-12-18 14:30:41 +00008355 // Load any pending macro definitions.
8356 for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00008357 IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
8358 SmallVector<PendingMacroInfo, 2> GlobalIDs;
8359 GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
8360 // Initialize the macro history from chained-PCHs ahead of module imports.
Richard Smith49f906a2014-03-01 00:08:04 +00008361 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
Argyrios Kyrtzidis719736c2013-01-19 03:14:56 +00008362 ++IDIdx) {
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00008363 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
Richard Smithe842a472014-10-22 02:05:46 +00008364 if (Info.M->Kind != MK_ImplicitModule &&
8365 Info.M->Kind != MK_ExplicitModule)
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00008366 resolvePendingMacro(II, Info);
8367 }
8368 // Handle module imports.
Richard Smith49f906a2014-03-01 00:08:04 +00008369 for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00008370 ++IDIdx) {
8371 const PendingMacroInfo &Info = GlobalIDs[IDIdx];
Richard Smithe842a472014-10-22 02:05:46 +00008372 if (Info.M->Kind == MK_ImplicitModule ||
8373 Info.M->Kind == MK_ExplicitModule)
Argyrios Kyrtzidiseb663da2013-03-22 21:12:57 +00008374 resolvePendingMacro(II, Info);
Guy Benyei11169dd2012-12-18 14:30:41 +00008375 }
8376 }
8377 PendingMacroIDs.clear();
Argyrios Kyrtzidis83a6e3b2013-02-16 00:48:59 +00008378
8379 // Wire up the DeclContexts for Decls that we delayed setting until
8380 // recursive loading is completed.
8381 while (!PendingDeclContextInfos.empty()) {
8382 PendingDeclContextInfo Info = PendingDeclContextInfos.front();
8383 PendingDeclContextInfos.pop_front();
8384 DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
8385 DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
8386 Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
8387 }
Richard Smith2b9e3e32013-10-18 06:05:18 +00008388
Richard Smithd1c46742014-04-30 02:24:17 +00008389 // Perform any pending declaration updates.
Richard Smithd6db68c2014-08-07 20:58:41 +00008390 while (!PendingUpdateRecords.empty()) {
Richard Smithd1c46742014-04-30 02:24:17 +00008391 auto Update = PendingUpdateRecords.pop_back_val();
8392 ReadingKindTracker ReadingKind(Read_Decl, *this);
8393 loadDeclUpdateRecords(Update.first, Update.second);
8394 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008395 }
Richard Smith8a639892015-01-24 01:07:20 +00008396
8397 // At this point, all update records for loaded decls are in place, so any
8398 // fake class definitions should have become real.
8399 assert(PendingFakeDefinitionData.empty() &&
8400 "faked up a class definition but never saw the real one");
8401
Guy Benyei11169dd2012-12-18 14:30:41 +00008402 // If we deserialized any C++ or Objective-C class definitions, any
8403 // Objective-C protocol definitions, or any redeclarable templates, make sure
8404 // that all redeclarations point to the definitions. Note that this can only
8405 // happen now, after the redeclaration chains have been fully wired.
Craig Topperc6914d02014-08-25 04:15:02 +00008406 for (Decl *D : PendingDefinitions) {
8407 if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
Richard Smith5b21db82014-04-23 18:20:42 +00008408 if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
Guy Benyei11169dd2012-12-18 14:30:41 +00008409 // Make sure that the TagType points at the definition.
8410 const_cast<TagType*>(TagT)->decl = TD;
8411 }
Richard Smith8ce51082015-03-11 01:44:51 +00008412
Craig Topperc6914d02014-08-25 04:15:02 +00008413 if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
Richard Smith8ce51082015-03-11 01:44:51 +00008414 for (auto *R = getMostRecentExistingDecl(RD); R;
8415 R = R->getPreviousDecl()) {
8416 assert((R == D) ==
8417 cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
Richard Smith2c381642014-08-27 23:11:59 +00008418 "declaration thinks it's the definition but it isn't");
Aaron Ballman86c93902014-03-06 23:45:36 +00008419 cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
Richard Smith2c381642014-08-27 23:11:59 +00008420 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008421 }
8422
8423 continue;
8424 }
Richard Smith8ce51082015-03-11 01:44:51 +00008425
Craig Topperc6914d02014-08-25 04:15:02 +00008426 if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
Guy Benyei11169dd2012-12-18 14:30:41 +00008427 // Make sure that the ObjCInterfaceType points at the definition.
8428 const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
8429 ->Decl = ID;
Richard Smith8ce51082015-03-11 01:44:51 +00008430
8431 for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
8432 cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
8433
Guy Benyei11169dd2012-12-18 14:30:41 +00008434 continue;
8435 }
Richard Smith8ce51082015-03-11 01:44:51 +00008436
Craig Topperc6914d02014-08-25 04:15:02 +00008437 if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
Richard Smith8ce51082015-03-11 01:44:51 +00008438 for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
8439 cast<ObjCProtocolDecl>(R)->Data = PD->Data;
8440
Guy Benyei11169dd2012-12-18 14:30:41 +00008441 continue;
8442 }
Richard Smith8ce51082015-03-11 01:44:51 +00008443
Craig Topperc6914d02014-08-25 04:15:02 +00008444 auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
Richard Smith8ce51082015-03-11 01:44:51 +00008445 for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
8446 cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
Guy Benyei11169dd2012-12-18 14:30:41 +00008447 }
8448 PendingDefinitions.clear();
8449
8450 // Load the bodies of any functions or methods we've encountered. We do
8451 // this now (delayed) so that we can be sure that the declaration chains
Richard Smithb9fa9962015-08-21 03:04:33 +00008452 // have been fully wired up (hasBody relies on this).
8453 // FIXME: We shouldn't require complete redeclaration chains here.
Guy Benyei11169dd2012-12-18 14:30:41 +00008454 for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
8455 PBEnd = PendingBodies.end();
8456 PB != PBEnd; ++PB) {
8457 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
8458 // FIXME: Check for =delete/=default?
8459 // FIXME: Complain about ODR violations here?
8460 if (!getContext().getLangOpts().Modules || !FD->hasBody())
8461 FD->setLazyBody(PB->second);
8462 continue;
8463 }
8464
8465 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
8466 if (!getContext().getLangOpts().Modules || !MD->hasBody())
8467 MD->setLazyBody(PB->second);
8468 }
8469 PendingBodies.clear();
Richard Smith42413142015-05-15 20:05:43 +00008470
8471 // Do some cleanup.
8472 for (auto *ND : PendingMergedDefinitionsToDeduplicate)
8473 getContext().deduplicateMergedDefinitonsFor(ND);
8474 PendingMergedDefinitionsToDeduplicate.clear();
Richard Smitha0ce9c42014-07-29 23:23:27 +00008475}
8476
8477void ASTReader::diagnoseOdrViolations() {
Richard Smithbb853c72014-08-13 01:23:33 +00008478 if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
8479 return;
8480
Richard Smitha0ce9c42014-07-29 23:23:27 +00008481 // Trigger the import of the full definition of each class that had any
8482 // odr-merging problems, so we can produce better diagnostics for them.
Richard Smithbb853c72014-08-13 01:23:33 +00008483 // These updates may in turn find and diagnose some ODR failures, so take
8484 // ownership of the set first.
8485 auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
8486 PendingOdrMergeFailures.clear();
8487 for (auto &Merge : OdrMergeFailures) {
Richard Smitha0ce9c42014-07-29 23:23:27 +00008488 Merge.first->buildLookup();
8489 Merge.first->decls_begin();
8490 Merge.first->bases_begin();
8491 Merge.first->vbases_begin();
8492 for (auto *RD : Merge.second) {
8493 RD->decls_begin();
8494 RD->bases_begin();
8495 RD->vbases_begin();
8496 }
8497 }
8498
8499 // For each declaration from a merged context, check that the canonical
8500 // definition of that context also contains a declaration of the same
8501 // entity.
8502 //
8503 // Caution: this loop does things that might invalidate iterators into
8504 // PendingOdrMergeChecks. Don't turn this into a range-based for loop!
8505 while (!PendingOdrMergeChecks.empty()) {
8506 NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
8507
8508 // FIXME: Skip over implicit declarations for now. This matters for things
8509 // like implicitly-declared special member functions. This isn't entirely
8510 // correct; we can end up with multiple unmerged declarations of the same
8511 // implicit entity.
8512 if (D->isImplicit())
8513 continue;
8514
8515 DeclContext *CanonDef = D->getDeclContext();
Richard Smitha0ce9c42014-07-29 23:23:27 +00008516
8517 bool Found = false;
8518 const Decl *DCanon = D->getCanonicalDecl();
8519
Richard Smith01bdb7a2014-08-28 05:44:07 +00008520 for (auto RI : D->redecls()) {
8521 if (RI->getLexicalDeclContext() == CanonDef) {
8522 Found = true;
8523 break;
8524 }
8525 }
8526 if (Found)
8527 continue;
8528
Richard Smith0f4e2c42015-08-06 04:23:48 +00008529 // Quick check failed, time to do the slow thing. Note, we can't just
8530 // look up the name of D in CanonDef here, because the member that is
8531 // in CanonDef might not be found by name lookup (it might have been
8532 // replaced by a more recent declaration in the lookup table), and we
8533 // can't necessarily find it in the redeclaration chain because it might
8534 // be merely mergeable, not redeclarable.
Richard Smitha0ce9c42014-07-29 23:23:27 +00008535 llvm::SmallVector<const NamedDecl*, 4> Candidates;
Richard Smith0f4e2c42015-08-06 04:23:48 +00008536 for (auto *CanonMember : CanonDef->decls()) {
8537 if (CanonMember->getCanonicalDecl() == DCanon) {
8538 // This can happen if the declaration is merely mergeable and not
8539 // actually redeclarable (we looked for redeclarations earlier).
8540 //
8541 // FIXME: We should be able to detect this more efficiently, without
8542 // pulling in all of the members of CanonDef.
8543 Found = true;
8544 break;
Richard Smitha0ce9c42014-07-29 23:23:27 +00008545 }
Richard Smith0f4e2c42015-08-06 04:23:48 +00008546 if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
8547 if (ND->getDeclName() == D->getDeclName())
8548 Candidates.push_back(ND);
Richard Smitha0ce9c42014-07-29 23:23:27 +00008549 }
8550
8551 if (!Found) {
Richard Smithd08aeb62014-08-28 01:33:39 +00008552 // The AST doesn't like TagDecls becoming invalid after they've been
8553 // completed. We only really need to mark FieldDecls as invalid here.
8554 if (!isa<TagDecl>(D))
8555 D->setInvalidDecl();
Richard Smith4ab3dbd2015-02-13 22:43:51 +00008556
8557 // Ensure we don't accidentally recursively enter deserialization while
8558 // we're producing our diagnostic.
8559 Deserializing RecursionGuard(this);
Richard Smitha0ce9c42014-07-29 23:23:27 +00008560
8561 std::string CanonDefModule =
8562 getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
8563 Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
8564 << D << getOwningModuleNameForDiagnostic(D)
8565 << CanonDef << CanonDefModule.empty() << CanonDefModule;
8566
8567 if (Candidates.empty())
8568 Diag(cast<Decl>(CanonDef)->getLocation(),
8569 diag::note_module_odr_violation_no_possible_decls) << D;
8570 else {
8571 for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
8572 Diag(Candidates[I]->getLocation(),
8573 diag::note_module_odr_violation_possible_decl)
8574 << Candidates[I];
8575 }
8576
8577 DiagnosedOdrMergeFailures.insert(CanonDef);
8578 }
8579 }
Richard Smithcd45dbc2014-04-19 03:48:30 +00008580
Richard Smith4ab3dbd2015-02-13 22:43:51 +00008581 if (OdrMergeFailures.empty())
8582 return;
8583
8584 // Ensure we don't accidentally recursively enter deserialization while
8585 // we're producing our diagnostics.
8586 Deserializing RecursionGuard(this);
8587
Richard Smithcd45dbc2014-04-19 03:48:30 +00008588 // Issue any pending ODR-failure diagnostics.
Richard Smithbb853c72014-08-13 01:23:33 +00008589 for (auto &Merge : OdrMergeFailures) {
Richard Smitha0ce9c42014-07-29 23:23:27 +00008590 // If we've already pointed out a specific problem with this class, don't
8591 // bother issuing a general "something's different" diagnostic.
David Blaikie82e95a32014-11-19 07:49:47 +00008592 if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
Richard Smithcd45dbc2014-04-19 03:48:30 +00008593 continue;
8594
8595 bool Diagnosed = false;
8596 for (auto *RD : Merge.second) {
8597 // Multiple different declarations got merged together; tell the user
8598 // where they came from.
8599 if (Merge.first != RD) {
8600 // FIXME: Walk the definition, figure out what's different,
8601 // and diagnose that.
8602 if (!Diagnosed) {
8603 std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
8604 Diag(Merge.first->getLocation(),
8605 diag::err_module_odr_violation_different_definitions)
8606 << Merge.first << Module.empty() << Module;
8607 Diagnosed = true;
8608 }
8609
8610 Diag(RD->getLocation(),
8611 diag::note_module_odr_violation_different_definitions)
8612 << getOwningModuleNameForDiagnostic(RD);
8613 }
8614 }
8615
8616 if (!Diagnosed) {
8617 // All definitions are updates to the same declaration. This happens if a
8618 // module instantiates the declaration of a class template specialization
8619 // and two or more other modules instantiate its definition.
8620 //
8621 // FIXME: Indicate which modules had instantiations of this definition.
8622 // FIXME: How can this even happen?
8623 Diag(Merge.first->getLocation(),
8624 diag::err_module_odr_violation_different_instantiations)
8625 << Merge.first;
8626 }
8627 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008628}
8629
Richard Smithce18a182015-07-14 00:26:00 +00008630void ASTReader::StartedDeserializing() {
8631 if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
8632 ReadTimer->startTimer();
8633}
8634
Guy Benyei11169dd2012-12-18 14:30:41 +00008635void ASTReader::FinishedDeserializing() {
8636 assert(NumCurrentElementsDeserializing &&
8637 "FinishedDeserializing not paired with StartedDeserializing");
8638 if (NumCurrentElementsDeserializing == 1) {
8639 // We decrease NumCurrentElementsDeserializing only after pending actions
8640 // are finished, to avoid recursively re-calling finishPendingActions().
8641 finishPendingActions();
8642 }
8643 --NumCurrentElementsDeserializing;
8644
Richard Smitha0ce9c42014-07-29 23:23:27 +00008645 if (NumCurrentElementsDeserializing == 0) {
Richard Smith9e2341d2015-03-23 03:25:59 +00008646 // Propagate exception specification updates along redeclaration chains.
Richard Smith7226f2a2015-03-23 19:54:56 +00008647 while (!PendingExceptionSpecUpdates.empty()) {
8648 auto Updates = std::move(PendingExceptionSpecUpdates);
8649 PendingExceptionSpecUpdates.clear();
8650 for (auto Update : Updates) {
8651 auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
Richard Smith1d0f1992015-08-19 21:09:32 +00008652 auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
Richard Smithd88a7f12015-09-01 20:35:42 +00008653 if (auto *Listener = Context.getASTMutationListener())
8654 Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
Richard Smith1d0f1992015-08-19 21:09:32 +00008655 for (auto *Redecl : Update.second->redecls())
8656 Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
Richard Smith7226f2a2015-03-23 19:54:56 +00008657 }
Richard Smith9e2341d2015-03-23 03:25:59 +00008658 }
8659
Richard Smithce18a182015-07-14 00:26:00 +00008660 if (ReadTimer)
8661 ReadTimer->stopTimer();
8662
Richard Smith0f4e2c42015-08-06 04:23:48 +00008663 diagnoseOdrViolations();
8664
Richard Smith04d05b52014-03-23 00:27:18 +00008665 // We are not in recursive loading, so it's safe to pass the "interesting"
8666 // decls to the consumer.
Richard Smitha0ce9c42014-07-29 23:23:27 +00008667 if (Consumer)
8668 PassInterestingDeclsToConsumer();
Guy Benyei11169dd2012-12-18 14:30:41 +00008669 }
8670}
8671
Argyrios Kyrtzidise5edbf92013-04-26 21:33:35 +00008672void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
Richard Smith9e2341d2015-03-23 03:25:59 +00008673 if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
8674 // Remove any fake results before adding any real ones.
8675 auto It = PendingFakeLookupResults.find(II);
8676 if (It != PendingFakeLookupResults.end()) {
Richard Smitha534a312015-07-21 23:54:07 +00008677 for (auto *ND : It->second)
Richard Smith9e2341d2015-03-23 03:25:59 +00008678 SemaObj->IdResolver.RemoveDecl(ND);
Ben Langmuireb8bd2d2015-04-10 22:25:42 +00008679 // FIXME: this works around module+PCH performance issue.
8680 // Rather than erase the result from the map, which is O(n), just clear
8681 // the vector of NamedDecls.
8682 It->second.clear();
Richard Smith9e2341d2015-03-23 03:25:59 +00008683 }
8684 }
Argyrios Kyrtzidise5edbf92013-04-26 21:33:35 +00008685
8686 if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
8687 SemaObj->TUScope->AddDecl(D);
8688 } else if (SemaObj->TUScope) {
8689 // Adding the decl to IdResolver may have failed because it was already in
8690 // (even though it was not added in scope). If it is already in, make sure
8691 // it gets in the scope as well.
8692 if (std::find(SemaObj->IdResolver.begin(Name),
8693 SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
8694 SemaObj->TUScope->AddDecl(D);
8695 }
8696}
8697
Douglas Gregor6623e1f2015-11-03 18:33:07 +00008698ASTReader::ASTReader(
8699 Preprocessor &PP, ASTContext &Context,
8700 const PCHContainerReader &PCHContainerRdr,
8701 ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,
8702 StringRef isysroot, bool DisableValidation,
8703 bool AllowASTWithCompilerErrors,
8704 bool AllowConfigurationMismatch, bool ValidateSystemInputs,
8705 bool UseGlobalIndex,
8706 std::unique_ptr<llvm::Timer> ReadTimer)
Craig Toppera13603a2014-05-22 05:54:18 +00008707 : Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr),
Nico Weber824285e2014-05-08 04:26:47 +00008708 OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
Adrian Prantlfb2398d2015-07-17 01:19:54 +00008709 FileMgr(PP.getFileManager()), PCHContainerRdr(PCHContainerRdr),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00008710 Diags(PP.getDiagnostics()), SemaObj(nullptr), PP(PP), Context(Context),
Adrian Prantlfb2398d2015-07-17 01:19:54 +00008711 Consumer(nullptr), ModuleMgr(PP.getFileManager(), PCHContainerRdr),
Richard Smithce18a182015-07-14 00:26:00 +00008712 ReadTimer(std::move(ReadTimer)),
Nico Weber779355f2016-03-02 23:22:00 +00008713 PragmaMSStructState(-1),
Nico Weber42932312016-03-03 00:17:35 +00008714 PragmaMSPointersToMembersState(-1),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00008715 isysroot(isysroot), DisableValidation(DisableValidation),
Nico Weber824285e2014-05-08 04:26:47 +00008716 AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
8717 AllowConfigurationMismatch(AllowConfigurationMismatch),
8718 ValidateSystemInputs(ValidateSystemInputs),
8719 UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
Adrian Prantlbb165fb2015-06-20 18:53:08 +00008720 CurrSwitchCaseStmts(&SwitchCaseStmts), NumSLocEntriesRead(0),
8721 TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0),
8722 NumMacrosRead(0), TotalNumMacros(0), NumIdentifierLookups(0),
8723 NumIdentifierLookupHits(0), NumSelectorsRead(0),
Nico Weber824285e2014-05-08 04:26:47 +00008724 NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
8725 NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
8726 NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
8727 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
8728 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
8729 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
Richard Smithc2bb8182015-03-24 06:36:48 +00008730 PassingDeclsToConsumer(false), ReadingKind(Read_None) {
Guy Benyei11169dd2012-12-18 14:30:41 +00008731 SourceMgr.setExternalSLocEntrySource(this);
Douglas Gregor6623e1f2015-11-03 18:33:07 +00008732
8733 for (const auto &Ext : Extensions) {
8734 auto BlockName = Ext->getExtensionMetadata().BlockName;
8735 auto Known = ModuleFileExtensions.find(BlockName);
8736 if (Known != ModuleFileExtensions.end()) {
8737 Diags.Report(diag::warn_duplicate_module_file_extension)
8738 << BlockName;
8739 continue;
8740 }
8741
8742 ModuleFileExtensions.insert({BlockName, Ext});
8743 }
Guy Benyei11169dd2012-12-18 14:30:41 +00008744}
8745
8746ASTReader::~ASTReader() {
Nico Weber824285e2014-05-08 04:26:47 +00008747 if (OwnsDeserializationListener)
8748 delete DeserializationListener;
Guy Benyei11169dd2012-12-18 14:30:41 +00008749}